review.tizen.org Git - platform/upstream/dotnet/runtime.git/blob

   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.Arm\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.Arm;
  17
  18 namespace JIT.HardwareIntrinsics.Arm
  19 {
  20     public static partial class Program
  21     {
  22         private static void CompareGreaterThanOrEqualScalar_Vector64_Double()
  23         {
  24             var test = new SimpleBinaryOpTest__CompareGreaterThanOrEqualScalar_Vector64_Double();
  25
  26             if (test.IsSupported)
  27             {
  28                 // Validates basic functionality works, using Unsafe.Read
  29                 test.RunBasicScenario_UnsafeRead();
  30
  31                 if (AdvSimd.IsSupported)
  32                 {
  33                     // Validates basic functionality works, using Load
  34                     test.RunBasicScenario_Load();
  35                 }
  36
  37                 // Validates calling via reflection works, using Unsafe.Read
  38                 test.RunReflectionScenario_UnsafeRead();
  39
  40                 if (AdvSimd.IsSupported)
  41                 {
  42                     // Validates calling via reflection works, using Load
  43                     test.RunReflectionScenario_Load();
  44                 }
  45
  46                 // Validates passing a static member works
  47                 test.RunClsVarScenario();
  48
  49                 if (AdvSimd.IsSupported)
  50                 {
  51                     // Validates passing a static member works, using pinning and Load
  52                     test.RunClsVarScenario_Load();
  53                 }
  54
  55                 // Validates passing a local works, using Unsafe.Read
  56                 test.RunLclVarScenario_UnsafeRead();
  57
  58                 if (AdvSimd.IsSupported)
  59                 {
  60                     // Validates passing a local works, using Load
  61                     test.RunLclVarScenario_Load();
  62                 }
  63
  64                 // Validates passing the field of a local class works
  65                 test.RunClassLclFldScenario();
  66
  67                 if (AdvSimd.IsSupported)
  68                 {
  69                     // Validates passing the field of a local class works, using pinning and Load
  70                     test.RunClassLclFldScenario_Load();
  71                 }
  72
  73                 // Validates passing an instance member of a class works
  74                 test.RunClassFldScenario();
  75
  76                 if (AdvSimd.IsSupported)
  77                 {
  78                     // Validates passing an instance member of a class works, using pinning and Load
  79                     test.RunClassFldScenario_Load();
  80                 }
  81
  82                 // Validates passing the field of a local struct works
  83                 test.RunStructLclFldScenario();
  84
  85                 if (AdvSimd.IsSupported)
  86                 {
  87                     // Validates passing the field of a local struct works, using pinning and Load
  88                     test.RunStructLclFldScenario_Load();
  89                 }
  90
  91                 // Validates passing an instance member of a struct works
  92                 test.RunStructFldScenario();
  93
  94                 if (AdvSimd.IsSupported)
  95                 {
  96                     // Validates passing an instance member of a struct works, using pinning and Load
  97                     test.RunStructFldScenario_Load();
  98                 }
  99             }
 100             else
 101             {
 102                 // Validates we throw on unsupported hardware
 103                 test.RunUnsupportedScenario();
 104             }
 105
 106             if (!test.Succeeded)
 107             {
 108                 throw new Exception("One or more scenarios did not complete as expected.");
 109             }
 110         }
 111     }
 112
 113     public sealed unsafe class SimpleBinaryOpTest__CompareGreaterThanOrEqualScalar_Vector64_Double
 114     {
 115         private struct DataTable
 116         {
 117             private byte[] inArray1;
 118             private byte[] inArray2;
 119             private byte[] outArray;
 120
 121             private GCHandle inHandle1;
 122             private GCHandle inHandle2;
 123             private GCHandle outHandle;
 124
 125             private ulong alignment;
 126
 127             public DataTable(Double[] inArray1, Double[] inArray2, Double[] outArray, int alignment)
 128             {
 129                 int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<Double>();
 130                 int sizeOfinArray2 = inArray2.Length * Unsafe.SizeOf<Double>();
 131                 int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<Double>();
 132                 if ((alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray2 || (alignment * 2) < sizeOfoutArray)
 133                 {
 134                     throw new ArgumentException("Invalid value of alignment");
 135                 }
 136
 137                 this.inArray1 = new byte[alignment * 2];
 138                 this.inArray2 = new byte[alignment * 2];
 139                 this.outArray = new byte[alignment * 2];
 140
 141                 this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned);
 142                 this.inHandle2 = GCHandle.Alloc(this.inArray2, GCHandleType.Pinned);
 143                 this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned);
 144
 145                 this.alignment = (ulong)alignment;
 146
 147                 Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray1Ptr), ref Unsafe.As<Double, byte>(ref inArray1[0]), (uint)sizeOfinArray1);
 148                 Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray2Ptr), ref Unsafe.As<Double, byte>(ref inArray2[0]), (uint)sizeOfinArray2);
 149             }
 150
 151             public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment);
 152             public void* inArray2Ptr => Align((byte*)(inHandle2.AddrOfPinnedObject().ToPointer()), alignment);
 153             public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment);
 154
 155             public void Dispose()
 156             {
 157                 inHandle1.Free();
 158                 inHandle2.Free();
 159                 outHandle.Free();
 160             }
 161
 162             private static unsafe void* Align(byte* buffer, ulong expectedAlignment)
 163             {
 164                 return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1));
 165             }
 166         }
 167
 168         private struct TestStruct
 169         {
 170             public Vector64<Double> _fld1;
 171             public Vector64<Double> _fld2;
 172
 173             public static TestStruct Create()
 174             {
 175                 var testStruct = new TestStruct();
 176
 177                 for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetDouble(); }
 178                 Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Double>, byte>(ref testStruct._fld1), ref Unsafe.As<Double, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<Double>>());
 179                 for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = TestLibrary.Generator.GetDouble(); }
 180                 Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Double>, byte>(ref testStruct._fld2), ref Unsafe.As<Double, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector64<Double>>());
 181
 182                 return testStruct;
 183             }
 184
 185             public void RunStructFldScenario(SimpleBinaryOpTest__CompareGreaterThanOrEqualScalar_Vector64_Double testClass)
 186             {
 187                 var result = AdvSimd.Arm64.CompareGreaterThanOrEqualScalar(_fld1, _fld2);
 188
 189                 Unsafe.Write(testClass._dataTable.outArrayPtr, result);
 190                 testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
 191             }
 192
 193             public void RunStructFldScenario_Load(SimpleBinaryOpTest__CompareGreaterThanOrEqualScalar_Vector64_Double testClass)
 194             {
 195                 fixed (Vector64<Double>* pFld1 = &_fld1)
 196                 fixed (Vector64<Double>* pFld2 = &_fld2)
 197                 {
 198                     var result = AdvSimd.Arm64.CompareGreaterThanOrEqualScalar(
 199                         AdvSimd.LoadVector64((Double*)(pFld1)),
 200                         AdvSimd.LoadVector64((Double*)(pFld2))
 201                     );
 202
 203                     Unsafe.Write(testClass._dataTable.outArrayPtr, result);
 204                     testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
 205                 }
 206             }
 207         }
 208
 209         private static readonly int LargestVectorSize = 8;
 210
 211         private static readonly int Op1ElementCount = Unsafe.SizeOf<Vector64<Double>>() / sizeof(Double);
 212         private static readonly int Op2ElementCount = Unsafe.SizeOf<Vector64<Double>>() / sizeof(Double);
 213         private static readonly int RetElementCount = Unsafe.SizeOf<Vector64<Double>>() / sizeof(Double);
 214
 215         private static Double[] _data1 = new Double[Op1ElementCount];
 216         private static Double[] _data2 = new Double[Op2ElementCount];
 217
 218         private static Vector64<Double> _clsVar1;
 219         private static Vector64<Double> _clsVar2;
 220
 221         private Vector64<Double> _fld1;
 222         private Vector64<Double> _fld2;
 223
 224         private DataTable _dataTable;
 225
 226         static SimpleBinaryOpTest__CompareGreaterThanOrEqualScalar_Vector64_Double()
 227         {
 228             for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetDouble(); }
 229             Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Double>, byte>(ref _clsVar1), ref Unsafe.As<Double, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<Double>>());
 230             for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = TestLibrary.Generator.GetDouble(); }
 231             Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Double>, byte>(ref _clsVar2), ref Unsafe.As<Double, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector64<Double>>());
 232         }
 233
 234         public SimpleBinaryOpTest__CompareGreaterThanOrEqualScalar_Vector64_Double()
 235         {
 236             Succeeded = true;
 237
 238             for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetDouble(); }
 239             Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Double>, byte>(ref _fld1), ref Unsafe.As<Double, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<Double>>());
 240             for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = TestLibrary.Generator.GetDouble(); }
 241             Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Double>, byte>(ref _fld2), ref Unsafe.As<Double, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector64<Double>>());
 242
 243             for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetDouble(); }
 244             for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = TestLibrary.Generator.GetDouble(); }
 245             _dataTable = new DataTable(_data1, _data2, new Double[RetElementCount], LargestVectorSize);
 246         }
 247
 248         public bool IsSupported => AdvSimd.Arm64.IsSupported;
 249
 250         public bool Succeeded { get; set; }
 251
 252         public void RunBasicScenario_UnsafeRead()
 253         {
 254             TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
 255
 256             var result = AdvSimd.Arm64.CompareGreaterThanOrEqualScalar(
 257                 Unsafe.Read<Vector64<Double>>(_dataTable.inArray1Ptr),
 258                 Unsafe.Read<Vector64<Double>>(_dataTable.inArray2Ptr)
 259             );
 260
 261             Unsafe.Write(_dataTable.outArrayPtr, result);
 262             ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
 263         }
 264
 265         public void RunBasicScenario_Load()
 266         {
 267             TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
 268
 269             var result = AdvSimd.Arm64.CompareGreaterThanOrEqualScalar(
 270                 AdvSimd.LoadVector64((Double*)(_dataTable.inArray1Ptr)),
 271                 AdvSimd.LoadVector64((Double*)(_dataTable.inArray2Ptr))
 272             );
 273
 274             Unsafe.Write(_dataTable.outArrayPtr, result);
 275             ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
 276         }
 277
 278         public void RunReflectionScenario_UnsafeRead()
 279         {
 280             TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
 281
 282             var result = typeof(AdvSimd.Arm64).GetMethod(nameof(AdvSimd.Arm64.CompareGreaterThanOrEqualScalar), new Type[] { typeof(Vector64<Double>), typeof(Vector64<Double>) })
 283                                      .Invoke(null, new object[] {
 284                                         Unsafe.Read<Vector64<Double>>(_dataTable.inArray1Ptr),
 285                                         Unsafe.Read<Vector64<Double>>(_dataTable.inArray2Ptr)
 286                                      });
 287
 288             Unsafe.Write(_dataTable.outArrayPtr, (Vector64<Double>)(result));
 289             ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
 290         }
 291
 292         public void RunReflectionScenario_Load()
 293         {
 294             TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
 295
 296             var result = typeof(AdvSimd.Arm64).GetMethod(nameof(AdvSimd.Arm64.CompareGreaterThanOrEqualScalar), new Type[] { typeof(Vector64<Double>), typeof(Vector64<Double>) })
 297                                      .Invoke(null, new object[] {
 298                                         AdvSimd.LoadVector64((Double*)(_dataTable.inArray1Ptr)),
 299                                         AdvSimd.LoadVector64((Double*)(_dataTable.inArray2Ptr))
 300                                      });
 301
 302             Unsafe.Write(_dataTable.outArrayPtr, (Vector64<Double>)(result));
 303             ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
 304         }
 305
 306         public void RunClsVarScenario()
 307         {
 308             TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
 309
 310             var result = AdvSimd.Arm64.CompareGreaterThanOrEqualScalar(
 311                 _clsVar1,
 312                 _clsVar2
 313             );
 314
 315             Unsafe.Write(_dataTable.outArrayPtr, result);
 316             ValidateResult(_clsVar1, _clsVar2, _dataTable.outArrayPtr);
 317         }
 318
 319         public void RunClsVarScenario_Load()
 320         {
 321             TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load));
 322
 323             fixed (Vector64<Double>* pClsVar1 = &_clsVar1)
 324             fixed (Vector64<Double>* pClsVar2 = &_clsVar2)
 325             {
 326                 var result = AdvSimd.Arm64.CompareGreaterThanOrEqualScalar(
 327                     AdvSimd.LoadVector64((Double*)(pClsVar1)),
 328                     AdvSimd.LoadVector64((Double*)(pClsVar2))
 329                 );
 330
 331                 Unsafe.Write(_dataTable.outArrayPtr, result);
 332                 ValidateResult(_clsVar1, _clsVar2, _dataTable.outArrayPtr);
 333             }
 334         }
 335
 336         public void RunLclVarScenario_UnsafeRead()
 337         {
 338             TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
 339
 340             var op1 = Unsafe.Read<Vector64<Double>>(_dataTable.inArray1Ptr);
 341             var op2 = Unsafe.Read<Vector64<Double>>(_dataTable.inArray2Ptr);
 342             var result = AdvSimd.Arm64.CompareGreaterThanOrEqualScalar(op1, op2);
 343
 344             Unsafe.Write(_dataTable.outArrayPtr, result);
 345             ValidateResult(op1, op2, _dataTable.outArrayPtr);
 346         }
 347
 348         public void RunLclVarScenario_Load()
 349         {
 350             TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load));
 351
 352             var op1 = AdvSimd.LoadVector64((Double*)(_dataTable.inArray1Ptr));
 353             var op2 = AdvSimd.LoadVector64((Double*)(_dataTable.inArray2Ptr));
 354             var result = AdvSimd.Arm64.CompareGreaterThanOrEqualScalar(op1, op2);
 355
 356             Unsafe.Write(_dataTable.outArrayPtr, result);
 357             ValidateResult(op1, op2, _dataTable.outArrayPtr);
 358         }
 359
 360         public void RunClassLclFldScenario()
 361         {
 362             TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
 363
 364             var test = new SimpleBinaryOpTest__CompareGreaterThanOrEqualScalar_Vector64_Double();
 365             var result = AdvSimd.Arm64.CompareGreaterThanOrEqualScalar(test._fld1, test._fld2);
 366
 367             Unsafe.Write(_dataTable.outArrayPtr, result);
 368             ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
 369         }
 370
 371         public void RunClassLclFldScenario_Load()
 372         {
 373             TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
 374
 375             var test = new SimpleBinaryOpTest__CompareGreaterThanOrEqualScalar_Vector64_Double();
 376
 377             fixed (Vector64<Double>* pFld1 = &test._fld1)
 378             fixed (Vector64<Double>* pFld2 = &test._fld2)
 379             {
 380                 var result = AdvSimd.Arm64.CompareGreaterThanOrEqualScalar(
 381                     AdvSimd.LoadVector64((Double*)(pFld1)),
 382                     AdvSimd.LoadVector64((Double*)(pFld2))
 383                 );
 384
 385                 Unsafe.Write(_dataTable.outArrayPtr, result);
 386                 ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
 387             }
 388         }
 389
 390         public void RunClassFldScenario()
 391         {
 392             TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
 393
 394             var result = AdvSimd.Arm64.CompareGreaterThanOrEqualScalar(_fld1, _fld2);
 395
 396             Unsafe.Write(_dataTable.outArrayPtr, result);
 397             ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
 398         }
 399
 400         public void RunClassFldScenario_Load()
 401         {
 402             TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load));
 403
 404             fixed (Vector64<Double>* pFld1 = &_fld1)
 405             fixed (Vector64<Double>* pFld2 = &_fld2)
 406             {
 407                 var result = AdvSimd.Arm64.CompareGreaterThanOrEqualScalar(
 408                     AdvSimd.LoadVector64((Double*)(pFld1)),
 409                     AdvSimd.LoadVector64((Double*)(pFld2))
 410                 );
 411
 412                 Unsafe.Write(_dataTable.outArrayPtr, result);
 413                 ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
 414             }
 415         }
 416
 417         public void RunStructLclFldScenario()
 418         {
 419             TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
 420
 421             var test = TestStruct.Create();
 422             var result = AdvSimd.Arm64.CompareGreaterThanOrEqualScalar(test._fld1, test._fld2);
 423
 424             Unsafe.Write(_dataTable.outArrayPtr, result);
 425             ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
 426         }
 427
 428         public void RunStructLclFldScenario_Load()
 429         {
 430             TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
 431
 432             var test = TestStruct.Create();
 433             var result = AdvSimd.Arm64.CompareGreaterThanOrEqualScalar(
 434                 AdvSimd.LoadVector64((Double*)(&test._fld1)),
 435                 AdvSimd.LoadVector64((Double*)(&test._fld2))
 436             );
 437
 438             Unsafe.Write(_dataTable.outArrayPtr, result);
 439             ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
 440         }
 441
 442         public void RunStructFldScenario()
 443         {
 444             TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario));
 445
 446             var test = TestStruct.Create();
 447             test.RunStructFldScenario(this);
 448         }
 449
 450         public void RunStructFldScenario_Load()
 451         {
 452             TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario_Load));
 453
 454             var test = TestStruct.Create();
 455             test.RunStructFldScenario_Load(this);
 456         }
 457
 458         public void RunUnsupportedScenario()
 459         {
 460             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 461
 462             bool succeeded = false;
 463
 464             try
 465             {
 466                 RunBasicScenario_UnsafeRead();
 467             }
 468             catch (PlatformNotSupportedException)
 469             {
 470                 succeeded = true;
 471             }
 472
 473             if (!succeeded)
 474             {
 475                 Succeeded = false;
 476             }
 477         }
 478
 479         private void ValidateResult(Vector64<Double> op1, Vector64<Double> op2, void* result, [CallerMemberName] string method = "")
 480         {
 481             Double[] inArray1 = new Double[Op1ElementCount];
 482             Double[] inArray2 = new Double[Op2ElementCount];
 483             Double[] outArray = new Double[RetElementCount];
 484
 485             Unsafe.WriteUnaligned(ref Unsafe.As<Double, byte>(ref inArray1[0]), op1);
 486             Unsafe.WriteUnaligned(ref Unsafe.As<Double, byte>(ref inArray2[0]), op2);
 487             Unsafe.CopyBlockUnaligned(ref Unsafe.As<Double, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector64<Double>>());
 488
 489             ValidateResult(inArray1, inArray2, outArray, method);
 490         }
 491
 492         private void ValidateResult(void* op1, void* op2, void* result, [CallerMemberName] string method = "")
 493         {
 494             Double[] inArray1 = new Double[Op1ElementCount];
 495             Double[] inArray2 = new Double[Op2ElementCount];
 496             Double[] outArray = new Double[RetElementCount];
 497
 498             Unsafe.CopyBlockUnaligned(ref Unsafe.As<Double, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(op1), (uint)Unsafe.SizeOf<Vector64<Double>>());
 499             Unsafe.CopyBlockUnaligned(ref Unsafe.As<Double, byte>(ref inArray2[0]), ref Unsafe.AsRef<byte>(op2), (uint)Unsafe.SizeOf<Vector64<Double>>());
 500             Unsafe.CopyBlockUnaligned(ref Unsafe.As<Double, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector64<Double>>());
 501
 502             ValidateResult(inArray1, inArray2, outArray, method);
 503         }
 504
 505         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
 506         {
 507             bool succeeded = true;
 508
 509             if (BitConverter.DoubleToInt64Bits(Helpers.CompareGreaterThanOrEqual(left[0], right[0])) != BitConverter.DoubleToInt64Bits(result[0]))
 510             {
 511                 succeeded = false;
 512             }
 513             else
 514             {
 515                 for (var i = 1; i < RetElementCount; i++)
 516                 {
 517                     if (BitConverter.DoubleToInt64Bits(result[i]) != 0)
 518                     {
 519                         succeeded = false;
 520                         break;
 521                     }
 522                 }
 523             }
 524
 525             if (!succeeded)
 526             {
 527                 TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd.Arm64)}.{nameof(AdvSimd.Arm64.CompareGreaterThanOrEqualScalar)}<Double>(Vector64<Double>, Vector64<Double>): {method} failed:");
 528                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
 529                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
 530                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
 531                 TestLibrary.TestFramework.LogInformation(string.Empty);
 532
 533                 Succeeded = false;
 534             }
 535         }
 536     }
 537 }