Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

[API Proposal]: Arm64: FEAT_SVE: counting #94003

Open
a74nh opened this issue Oct 26, 2023 · 18 comments
Open

[API Proposal]: Arm64: FEAT_SVE: counting #94003

a74nh opened this issue Oct 26, 2023 · 18 comments
Labels
api-approved API was approved in API review, it can be implemented area-System.Runtime.Intrinsics arm-sve Work related to arm64 SVE/SVE2 support
Milestone
10.0.0

Comments

@a74nh
Copy link
Contributor

a74nh commented Oct 26, 2023 •
edited
Loading 

namespace System.Runtime.Intrinsics.Arm

/// VectorT Summary
public abstract class Sve : AdvSimd /// Feature: FEAT_SVE  Category: counting
{

  public static unsafe ulong Count16BitElements(); // CNTH

  public static unsafe ulong Count16BitElements(enum SveMaskPattern pattern); // CNTH

  public static unsafe ulong Count32BitElements(); // CNTW

  public static unsafe ulong Count32BitElements(enum SveMaskPattern pattern); // CNTW

  public static unsafe ulong Count64BitElements(); // CNTD

  public static unsafe ulong Count64BitElements(enum SveMaskPattern pattern); // CNTD

  public static unsafe ulong Count8BitElements(); // CNTB

  public static unsafe ulong Count8BitElements(enum SveMaskPattern pattern); // CNTB

  /// T: byte, ushort, uint, ulong
  public static unsafe ulong GetActiveElementCount(Vector<T> mask, Vector<T> from); // CNTP

  /// T: [byte, sbyte], [ushort, short], [uint, int], [ulong, long]
  public static unsafe Vector<T> LeadingSignCount(Vector<T2> value); // CLS // predicated, MOVPRFX

  /// T: [byte, sbyte], [ushort, short], [uint, int], [ulong, long]
  public static unsafe Vector<T> LeadingZeroCount(Vector<T2> value); // CLZ // predicated, MOVPRFX

  /// T: byte, ushort, uint, ulong
  public static unsafe Vector<T> LeadingZeroCount(Vector<T> value); // CLZ // predicated, MOVPRFX

  /// T: [uint, float], [ulong, double], [byte, sbyte], [ushort, short], [uint, int], [ulong, long]
  public static unsafe Vector<T> PopCount(Vector<T2> value); // CNT // predicated, MOVPRFX

  /// T: byte, ushort, uint, ulong
  public static unsafe Vector<T> PopCount(Vector<T> value); // CNT // predicated, MOVPRFX

  /// T: byte, ushort, uint, ulong
  public static unsafe int SaturatingDecrementByActiveElementCount(int op, Vector<T> from); // SQDECP

  /// T: byte, ushort, uint, ulong
  public static unsafe long SaturatingDecrementByActiveElementCount(long op, Vector<T> from); // SQDECP

  /// T: byte, ushort, uint, ulong
  public static unsafe uint SaturatingDecrementByActiveElementCount(uint op, Vector<T> from); // UQDECP

  /// T: byte, ushort, uint, ulong
  public static unsafe ulong SaturatingDecrementByActiveElementCount(ulong op, Vector<T> from); // UQDECP

  /// T: short, int, long, ushort, uint, ulong
  public static unsafe Vector<T> SaturatingDecrementByActiveElementCount(Vector<T> op, Vector<T> from); // SQDECP or UQDECP // MOVPRFX

  public static unsafe int SaturatingDecrementByteElementCount(int op, ulong imm_factor); // SQDECB

  public static unsafe long SaturatingDecrementByteElementCount(long op, ulong imm_factor); // SQDECB

  public static unsafe uint SaturatingDecrementByteElementCount(uint op, ulong imm_factor); // UQDECB

  public static unsafe ulong SaturatingDecrementByteElementCount(ulong op, ulong imm_factor); // UQDECB

  public static unsafe int SaturatingDecrementByteElementCount(int op, enum SveMaskPattern pattern, ulong imm_factor); // SQDECB

  public static unsafe long SaturatingDecrementByteElementCount(long op, enum SveMaskPattern pattern, ulong imm_factor); // SQDECB

  public static unsafe uint SaturatingDecrementByteElementCount(uint op, enum SveMaskPattern pattern, ulong imm_factor); // UQDECB

  public static unsafe ulong SaturatingDecrementByteElementCount(ulong op, enum SveMaskPattern pattern, ulong imm_factor); // UQDECB

  public static unsafe int SaturatingDecrementInt16ElementCount(int op, ulong imm_factor); // SQDECH

  public static unsafe long SaturatingDecrementInt16ElementCount(long op, ulong imm_factor); // SQDECH

  public static unsafe uint SaturatingDecrementInt16ElementCount(uint op, ulong imm_factor); // UQDECH

  public static unsafe ulong SaturatingDecrementInt16ElementCount(ulong op, ulong imm_factor); // UQDECH

  public static unsafe int SaturatingDecrementInt16ElementCount(int op, enum SveMaskPattern pattern, ulong imm_factor); // SQDECH

  public static unsafe long SaturatingDecrementInt16ElementCount(long op, enum SveMaskPattern pattern, ulong imm_factor); // SQDECH

  public static unsafe uint SaturatingDecrementInt16ElementCount(uint op, enum SveMaskPattern pattern, ulong imm_factor); // UQDECH

  public static unsafe ulong SaturatingDecrementInt16ElementCount(ulong op, enum SveMaskPattern pattern, ulong imm_factor); // UQDECH

  /// T: short, ushort
  public static unsafe Vector<T> SaturatingDecrementInt16ElementCount(Vector<T> op, ulong imm_factor); // SQDECH or UQDECH // MOVPRFX

  /// T: short, ushort
  public static unsafe Vector<T> SaturatingDecrementInt16ElementCount(Vector<T> op, enum SveMaskPattern pattern, ulong imm_factor); // SQDECH or UQDECH // MOVPRFX

  public static unsafe int SaturatingDecrementInt32ElementCount(int op, ulong imm_factor); // SQDECW

  public static unsafe long SaturatingDecrementInt32ElementCount(long op, ulong imm_factor); // SQDECW

  public static unsafe uint SaturatingDecrementInt32ElementCount(uint op, ulong imm_factor); // UQDECW

  public static unsafe ulong SaturatingDecrementInt32ElementCount(ulong op, ulong imm_factor); // UQDECW

  public static unsafe int SaturatingDecrementInt32ElementCount(int op, enum SveMaskPattern pattern, ulong imm_factor); // SQDECW

  public static unsafe long SaturatingDecrementInt32ElementCount(long op, enum SveMaskPattern pattern, ulong imm_factor); // SQDECW

  public static unsafe uint SaturatingDecrementInt32ElementCount(uint op, enum SveMaskPattern pattern, ulong imm_factor); // UQDECW

  public static unsafe ulong SaturatingDecrementInt32ElementCount(ulong op, enum SveMaskPattern pattern, ulong imm_factor); // UQDECW

  /// T: int, uint
  public static unsafe Vector<T> SaturatingDecrementInt32ElementCount(Vector<T> op, ulong imm_factor); // SQDECW or UQDECW // MOVPRFX

  /// T: int, uint
  public static unsafe Vector<T> SaturatingDecrementInt32ElementCount(Vector<T> op, enum SveMaskPattern pattern, ulong imm_factor); // SQDECW or UQDECW // MOVPRFX

  public static unsafe int SaturatingDecrementInt64ElementCount(int op, ulong imm_factor); // SQDECD

  public static unsafe long SaturatingDecrementInt64ElementCount(long op, ulong imm_factor); // SQDECD

  public static unsafe uint SaturatingDecrementInt64ElementCount(uint op, ulong imm_factor); // UQDECD

  public static unsafe ulong SaturatingDecrementInt64ElementCount(ulong op, ulong imm_factor); // UQDECD

  public static unsafe int SaturatingDecrementInt64ElementCount(int op, enum SveMaskPattern pattern, ulong imm_factor); // SQDECD

  public static unsafe long SaturatingDecrementInt64ElementCount(long op, enum SveMaskPattern pattern, ulong imm_factor); // SQDECD

  public static unsafe uint SaturatingDecrementInt64ElementCount(uint op, enum SveMaskPattern pattern, ulong imm_factor); // UQDECD

  public static unsafe ulong SaturatingDecrementInt64ElementCount(ulong op, enum SveMaskPattern pattern, ulong imm_factor); // UQDECD

  /// T: long, ulong
  public static unsafe Vector<T> SaturatingDecrementInt64ElementCount(Vector<T> op, ulong imm_factor); // SQDECD or UQDECD // MOVPRFX

  /// T: long, ulong
  public static unsafe Vector<T> SaturatingDecrementInt64ElementCount(Vector<T> op, enum SveMaskPattern pattern, ulong imm_factor); // SQDECD or UQDECD // MOVPRFX

  /// T: byte, ushort, uint, ulong
  public static unsafe int SaturatingIncrementByActiveElementCount(int op, Vector<T> from); // SQINCP

  /// T: byte, ushort, uint, ulong
  public static unsafe long SaturatingIncrementByActiveElementCount(long op, Vector<T> from); // SQINCP

  /// T: byte, ushort, uint, ulong
  public static unsafe uint SaturatingIncrementByActiveElementCount(uint op, Vector<T> from); // UQINCP

  /// T: byte, ushort, uint, ulong
  public static unsafe ulong SaturatingIncrementByActiveElementCount(ulong op, Vector<T> from); // UQINCP

  /// T: short, int, long, ushort, uint, ulong
  public static unsafe Vector<T> SaturatingIncrementByActiveElementCount(Vector<T> op, Vector<T> from); // SQINCP or UQINCP // MOVPRFX

  public static unsafe int SaturatingIncrementByteElementCount(int op, ulong imm_factor); // SQINCB

  public static unsafe long SaturatingIncrementByteElementCount(long op, ulong imm_factor); // SQINCB

  public static unsafe uint SaturatingIncrementByteElementCount(uint op, ulong imm_factor); // UQINCB

  public static unsafe ulong SaturatingIncrementByteElementCount(ulong op, ulong imm_factor); // UQINCB

  public static unsafe int SaturatingIncrementByteElementCount(int op, enum SveMaskPattern pattern, ulong imm_factor); // SQINCB

  public static unsafe long SaturatingIncrementByteElementCount(long op, enum SveMaskPattern pattern, ulong imm_factor); // SQINCB

  public static unsafe uint SaturatingIncrementByteElementCount(uint op, enum SveMaskPattern pattern, ulong imm_factor); // UQINCB

  public static unsafe ulong SaturatingIncrementByteElementCount(ulong op, enum SveMaskPattern pattern, ulong imm_factor); // UQINCB

  public static unsafe int SaturatingIncrementInt16ElementCount(int op, ulong imm_factor); // SQINCH

  public static unsafe long SaturatingIncrementInt16ElementCount(long op, ulong imm_factor); // SQINCH

  public static unsafe uint SaturatingIncrementInt16ElementCount(uint op, ulong imm_factor); // UQINCH

  public static unsafe ulong SaturatingIncrementInt16ElementCount(ulong op, ulong imm_factor); // UQINCH

  public static unsafe int SaturatingIncrementInt16ElementCount(int op, enum SveMaskPattern pattern, ulong imm_factor); // SQINCH

  public static unsafe long SaturatingIncrementInt16ElementCount(long op, enum SveMaskPattern pattern, ulong imm_factor); // SQINCH

  public static unsafe uint SaturatingIncrementInt16ElementCount(uint op, enum SveMaskPattern pattern, ulong imm_factor); // UQINCH

  public static unsafe ulong SaturatingIncrementInt16ElementCount(ulong op, enum SveMaskPattern pattern, ulong imm_factor); // UQINCH

  /// T: short, ushort
  public static unsafe Vector<T> SaturatingIncrementInt16ElementCount(Vector<T> op, ulong imm_factor); // SQINCH or UQINCH // MOVPRFX

  /// T: short, ushort
  public static unsafe Vector<T> SaturatingIncrementInt16ElementCount(Vector<T> op, enum SveMaskPattern pattern, ulong imm_factor); // SQINCH or UQINCH // MOVPRFX

  public static unsafe int SaturatingIncrementInt32ElementCount(int op, ulong imm_factor); // SQINCW

  public static unsafe long SaturatingIncrementInt32ElementCount(long op, ulong imm_factor); // SQINCW

  public static unsafe uint SaturatingIncrementInt32ElementCount(uint op, ulong imm_factor); // UQINCW

  public static unsafe ulong SaturatingIncrementInt32ElementCount(ulong op, ulong imm_factor); // UQINCW

  public static unsafe int SaturatingIncrementInt32ElementCount(int op, enum SveMaskPattern pattern, ulong imm_factor); // SQINCW

  public static unsafe long SaturatingIncrementInt32ElementCount(long op, enum SveMaskPattern pattern, ulong imm_factor); // SQINCW

  public static unsafe uint SaturatingIncrementInt32ElementCount(uint op, enum SveMaskPattern pattern, ulong imm_factor); // UQINCW

  public static unsafe ulong SaturatingIncrementInt32ElementCount(ulong op, enum SveMaskPattern pattern, ulong imm_factor); // UQINCW

  /// T: int, uint
  public static unsafe Vector<T> SaturatingIncrementInt32ElementCount(Vector<T> op, ulong imm_factor); // SQINCW or UQINCW // MOVPRFX

  /// T: int, uint
  public static unsafe Vector<T> SaturatingIncrementInt32ElementCount(Vector<T> op, enum SveMaskPattern pattern, ulong imm_factor); // SQINCW or UQINCW // MOVPRFX

  public static unsafe int SaturatingIncrementInt64ElementCount(int op, ulong imm_factor); // SQINCD

  public static unsafe long SaturatingIncrementInt64ElementCount(long op, ulong imm_factor); // SQINCD

  public static unsafe uint SaturatingIncrementInt64ElementCount(uint op, ulong imm_factor); // UQINCD

  public static unsafe ulong SaturatingIncrementInt64ElementCount(ulong op, ulong imm_factor); // UQINCD

  public static unsafe int SaturatingIncrementInt64ElementCount(int op, enum SveMaskPattern pattern, ulong imm_factor); // SQINCD

  public static unsafe long SaturatingIncrementInt64ElementCount(long op, enum SveMaskPattern pattern, ulong imm_factor); // SQINCD

  public static unsafe uint SaturatingIncrementInt64ElementCount(uint op, enum SveMaskPattern pattern, ulong imm_factor); // UQINCD

  public static unsafe ulong SaturatingIncrementInt64ElementCount(ulong op, enum SveMaskPattern pattern, ulong imm_factor); // UQINCD

  /// T: long, ulong
  public static unsafe Vector<T> SaturatingIncrementInt64ElementCount(Vector<T> op, ulong imm_factor); // SQINCD or UQINCD // MOVPRFX

  /// T: long, ulong
  public static unsafe Vector<T> SaturatingIncrementInt64ElementCount(Vector<T> op, enum SveMaskPattern pattern, ulong imm_factor); // SQINCD or UQINCD // MOVPRFX


  // All patterns used by PTRUE.
  enum SveMaskPattern
  {
    SV_POW2 = 0,   // The largest power of 2.
    SV_VL1 = 1,    // 1 element.
    SV_VL2 = 2,    // 2 elements.
    SV_VL3 = 3,    // 3 elements.
    SV_VL4 = 4,    // 4 elements.
    SV_VL5 = 5,    // 5 elements.
    SV_VL6 = 6,    // 6 elements.
    SV_VL7 = 7,    // 7 elements.
    SV_VL8 = 8,    // 8 elements.
    SV_VL16 = 9,   // 16 elements.
    SV_VL32 = 10,  // 32 elements.
    SV_VL64 = 11,  // 64 elements.
    SV_VL128 = 12, // 128 elements.
    SV_VL256 = 13, // 256 elements.
    SV_MUL4 = 29,  // The largest multiple of 3.
    SV_MUL3 = 30,  // The largest multiple of 4.
    SV_ALL = 31    // All available (implicitly a multiple of two).
  };

  /// total method signatures: 100

}

Details

CountNBitElements(enum SveMaskPattern pattern)
Set scalar to multiple of predicate constraint element count
Determines the number of active elements implied by pattern, multiplies that by an immediate in the range 1 to 16 inclusive, and then places the result in the scalar destination.

Pattern limits the number of active elements in a single predicate to:

  • A fixed number (VL1 to VL256)
  • The largest power of two (POW2)
  • The largest multiple of three or four (MUL3 or MUL4)
  • All available, implicitly a multiple of two (ALL).

CountNBitElements()
Identical to: CountNBitElements(SV_ALL)
@ghost ghost added the untriaged New issue has not been triaged by the area owner label Oct 26, 2023
@ghost
Copy link

ghost commented Oct 26, 2023

Tagging subscribers to this area: @dotnet/area-system-numerics
See info in area-owners.md if you want to be subscribed.

Issue Details 
namespace System.Runtime.Intrinsics.Arm

/// VectorT Summary
public abstract class Sve : AdvSimd /// Feature: FEAT_SVE  Category: count
{
  /// T: [byte, sbyte], [ushort, short], [uint, int], [ulong, long]
  public static unsafe Vector<T> CountLeadingSignBits(Vector<T2> value); // CLS (MOVPRFX)

  /// T: [byte, sbyte], [ushort, short], [uint, int], [ulong, long]
  public static unsafe Vector<T> CountLeadingZeroBits(Vector<T2> value); // CLZ (MOVPRFX)

  /// T: byte, ushort, uint, ulong
  public static unsafe Vector<T> CountLeadingZeroBits(Vector<T> value); // CLZ (MOVPRFX)

  /// T: [uint, float], [ulong, double], [byte, sbyte], [ushort, short], [uint, int], [ulong, long]
  public static unsafe Vector<T> CountNonzeroBits(Vector<T2> value); // CNT (MOVPRFX)

  /// T: byte, ushort, uint, ulong
  public static unsafe Vector<T> CountNonzeroBits(Vector<T> value); // CNT (MOVPRFX)

  /// T: byte, ushort, uint, ulong
  public static unsafe ulong CountSetPredicateBits(Vector<T> value); // CNTP

  public static unsafe ulong CountTheNumberOf16BitElementsInAVector();

  public static unsafe ulong CountTheNumberOf16BitElementsInAVector(enum svpattern pattern);

  public static unsafe ulong CountTheNumberOf32BitElementsInAVector();

  public static unsafe ulong CountTheNumberOf32BitElementsInAVector(enum svpattern pattern);

  public static unsafe ulong CountTheNumberOf64BitElementsInAVector();

  public static unsafe ulong CountTheNumberOf64BitElementsInAVector(enum svpattern pattern);

  public static unsafe ulong CountTheNumberOf8BitElementsInAVector();

  public static unsafe ulong CountTheNumberOf8BitElementsInAVector(enum svpattern pattern);

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe ulong CountTheNumberOfElementsInAFullVector(Vector<T> value); // CNTW or CNTD or CNTB or CNTH

  /// T: byte, ushort, uint, ulong
  public static unsafe int SaturatingDecrementByActiveElementCount(int op, Vector<T> mask); // SQDECP

  /// T: byte, ushort, uint, ulong
  public static unsafe long SaturatingDecrementByActiveElementCount(long op, Vector<T> mask); // SQDECP

  /// T: byte, ushort, uint, ulong
  public static unsafe uint SaturatingDecrementByActiveElementCount(uint op, Vector<T> mask); // UQDECP

  /// T: byte, ushort, uint, ulong
  public static unsafe ulong SaturatingDecrementByActiveElementCount(ulong op, Vector<T> mask); // UQDECP

  /// T: short, int, long, ushort, uint, ulong
  public static unsafe Vector<T> SaturatingDecrementByActiveElementCount(Vector<T> op, Vector<T> mask); // SQDECP or UQDECP (MOVPRFX)

  public static unsafe int SaturatingDecrementByNumberOfByteElements(int op, ulong imm_factor);

  public static unsafe long SaturatingDecrementByNumberOfByteElements(long op, ulong imm_factor);

  public static unsafe uint SaturatingDecrementByNumberOfByteElements(uint op, ulong imm_factor);

  public static unsafe ulong SaturatingDecrementByNumberOfByteElements(ulong op, ulong imm_factor);

  public static unsafe int SaturatingDecrementByNumberOfByteElements(int op, enum svpattern pattern, ulong imm_factor);

  public static unsafe long SaturatingDecrementByNumberOfByteElements(long op, enum svpattern pattern, ulong imm_factor);

  public static unsafe uint SaturatingDecrementByNumberOfByteElements(uint op, enum svpattern pattern, ulong imm_factor);

  public static unsafe ulong SaturatingDecrementByNumberOfByteElements(ulong op, enum svpattern pattern, ulong imm_factor);

  public static unsafe int SaturatingDecrementByNumberOfDoublewordElements(int op, ulong imm_factor);

  public static unsafe long SaturatingDecrementByNumberOfDoublewordElements(long op, ulong imm_factor);

  public static unsafe uint SaturatingDecrementByNumberOfDoublewordElements(uint op, ulong imm_factor);

  public static unsafe ulong SaturatingDecrementByNumberOfDoublewordElements(ulong op, ulong imm_factor);

  public static unsafe int SaturatingDecrementByNumberOfDoublewordElements(int op, enum svpattern pattern, ulong imm_factor);

  public static unsafe long SaturatingDecrementByNumberOfDoublewordElements(long op, enum svpattern pattern, ulong imm_factor);

  public static unsafe uint SaturatingDecrementByNumberOfDoublewordElements(uint op, enum svpattern pattern, ulong imm_factor);

  public static unsafe ulong SaturatingDecrementByNumberOfDoublewordElements(ulong op, enum svpattern pattern, ulong imm_factor);

  /// T: long, ulong
  public static unsafe Vector<T> SaturatingDecrementByNumberOfDoublewordElements(Vector<T> op, ulong imm_factor); // SQDECD or UQDECD (MOVPRFX)

  /// T: long, ulong
  public static unsafe Vector<T> SaturatingDecrementByNumberOfDoublewordElements(Vector<T> op, enum svpattern pattern, ulong imm_factor); // SQDECD or UQDECD (MOVPRFX)

  public static unsafe int SaturatingDecrementByNumberOfHalfwordElements(int op, ulong imm_factor);

  public static unsafe long SaturatingDecrementByNumberOfHalfwordElements(long op, ulong imm_factor);

  public static unsafe uint SaturatingDecrementByNumberOfHalfwordElements(uint op, ulong imm_factor);

  public static unsafe ulong SaturatingDecrementByNumberOfHalfwordElements(ulong op, ulong imm_factor);

  public static unsafe int SaturatingDecrementByNumberOfHalfwordElements(int op, enum svpattern pattern, ulong imm_factor);

  public static unsafe long SaturatingDecrementByNumberOfHalfwordElements(long op, enum svpattern pattern, ulong imm_factor);

  public static unsafe uint SaturatingDecrementByNumberOfHalfwordElements(uint op, enum svpattern pattern, ulong imm_factor);

  public static unsafe ulong SaturatingDecrementByNumberOfHalfwordElements(ulong op, enum svpattern pattern, ulong imm_factor);

  /// T: short, ushort
  public static unsafe Vector<T> SaturatingDecrementByNumberOfHalfwordElements(Vector<T> op, ulong imm_factor); // SQDECH or UQDECH (MOVPRFX)

  /// T: short, ushort
  public static unsafe Vector<T> SaturatingDecrementByNumberOfHalfwordElements(Vector<T> op, enum svpattern pattern, ulong imm_factor); // SQDECH or UQDECH (MOVPRFX)

  public static unsafe int SaturatingDecrementByNumberOfWordElements(int op, ulong imm_factor);

  public static unsafe long SaturatingDecrementByNumberOfWordElements(long op, ulong imm_factor);

  public static unsafe uint SaturatingDecrementByNumberOfWordElements(uint op, ulong imm_factor);

  public static unsafe ulong SaturatingDecrementByNumberOfWordElements(ulong op, ulong imm_factor);

  public static unsafe int SaturatingDecrementByNumberOfWordElements(int op, enum svpattern pattern, ulong imm_factor);

  public static unsafe long SaturatingDecrementByNumberOfWordElements(long op, enum svpattern pattern, ulong imm_factor);

  public static unsafe uint SaturatingDecrementByNumberOfWordElements(uint op, enum svpattern pattern, ulong imm_factor);

  public static unsafe ulong SaturatingDecrementByNumberOfWordElements(ulong op, enum svpattern pattern, ulong imm_factor);

  /// T: int, uint
  public static unsafe Vector<T> SaturatingDecrementByNumberOfWordElements(Vector<T> op, ulong imm_factor); // SQDECW or UQDECW (MOVPRFX)

  /// T: int, uint
  public static unsafe Vector<T> SaturatingDecrementByNumberOfWordElements(Vector<T> op, enum svpattern pattern, ulong imm_factor); // SQDECW or UQDECW (MOVPRFX)

  /// T: byte, ushort, uint, ulong
  public static unsafe int SaturatingIncrementByActiveElementCount(int op, Vector<T> mask); // SQINCP

  /// T: byte, ushort, uint, ulong
  public static unsafe long SaturatingIncrementByActiveElementCount(long op, Vector<T> mask); // SQINCP

  /// T: byte, ushort, uint, ulong
  public static unsafe uint SaturatingIncrementByActiveElementCount(uint op, Vector<T> mask); // UQINCP

  /// T: byte, ushort, uint, ulong
  public static unsafe ulong SaturatingIncrementByActiveElementCount(ulong op, Vector<T> mask); // UQINCP

  /// T: short, int, long, ushort, uint, ulong
  public static unsafe Vector<T> SaturatingIncrementByActiveElementCount(Vector<T> op, Vector<T> mask); // SQINCP or UQINCP (MOVPRFX)

  public static unsafe int SaturatingIncrementByNumberOfByteElements(int op, ulong imm_factor);

  public static unsafe long SaturatingIncrementByNumberOfByteElements(long op, ulong imm_factor);

  public static unsafe uint SaturatingIncrementByNumberOfByteElements(uint op, ulong imm_factor);

  public static unsafe ulong SaturatingIncrementByNumberOfByteElements(ulong op, ulong imm_factor);

  public static unsafe int SaturatingIncrementByNumberOfByteElements(int op, enum svpattern pattern, ulong imm_factor);

  public static unsafe long SaturatingIncrementByNumberOfByteElements(long op, enum svpattern pattern, ulong imm_factor);

  public static unsafe uint SaturatingIncrementByNumberOfByteElements(uint op, enum svpattern pattern, ulong imm_factor);

  public static unsafe ulong SaturatingIncrementByNumberOfByteElements(ulong op, enum svpattern pattern, ulong imm_factor);

  public static unsafe int SaturatingIncrementByNumberOfDoublewordElements(int op, ulong imm_factor);

  public static unsafe long SaturatingIncrementByNumberOfDoublewordElements(long op, ulong imm_factor);

  public static unsafe uint SaturatingIncrementByNumberOfDoublewordElements(uint op, ulong imm_factor);

  public static unsafe ulong SaturatingIncrementByNumberOfDoublewordElements(ulong op, ulong imm_factor);

  public static unsafe int SaturatingIncrementByNumberOfDoublewordElements(int op, enum svpattern pattern, ulong imm_factor);

  public static unsafe long SaturatingIncrementByNumberOfDoublewordElements(long op, enum svpattern pattern, ulong imm_factor);

  public static unsafe uint SaturatingIncrementByNumberOfDoublewordElements(uint op, enum svpattern pattern, ulong imm_factor);

  public static unsafe ulong SaturatingIncrementByNumberOfDoublewordElements(ulong op, enum svpattern pattern, ulong imm_factor);

  /// T: long, ulong
  public static unsafe Vector<T> SaturatingIncrementByNumberOfDoublewordElements(Vector<T> op, ulong imm_factor); // SQINCD or UQINCD (MOVPRFX)

  /// T: long, ulong
  public static unsafe Vector<T> SaturatingIncrementByNumberOfDoublewordElements(Vector<T> op, enum svpattern pattern, ulong imm_factor); // SQINCD or UQINCD (MOVPRFX)

  public static unsafe int SaturatingIncrementByNumberOfHalfwordElements(int op, ulong imm_factor);

  public static unsafe long SaturatingIncrementByNumberOfHalfwordElements(long op, ulong imm_factor);

  public static unsafe uint SaturatingIncrementByNumberOfHalfwordElements(uint op, ulong imm_factor);

  public static unsafe ulong SaturatingIncrementByNumberOfHalfwordElements(ulong op, ulong imm_factor);

  public static unsafe int SaturatingIncrementByNumberOfHalfwordElements(int op, enum svpattern pattern, ulong imm_factor);

  public static unsafe long SaturatingIncrementByNumberOfHalfwordElements(long op, enum svpattern pattern, ulong imm_factor);

  public static unsafe uint SaturatingIncrementByNumberOfHalfwordElements(uint op, enum svpattern pattern, ulong imm_factor);

  public static unsafe ulong SaturatingIncrementByNumberOfHalfwordElements(ulong op, enum svpattern pattern, ulong imm_factor);

  /// T: short, ushort
  public static unsafe Vector<T> SaturatingIncrementByNumberOfHalfwordElements(Vector<T> op, ulong imm_factor); // SQINCH or UQINCH (MOVPRFX)

  /// T: short, ushort
  public static unsafe Vector<T> SaturatingIncrementByNumberOfHalfwordElements(Vector<T> op, enum svpattern pattern, ulong imm_factor); // SQINCH or UQINCH (MOVPRFX)

  public static unsafe int SaturatingIncrementByNumberOfWordElements(int op, ulong imm_factor);

  public static unsafe long SaturatingIncrementByNumberOfWordElements(long op, ulong imm_factor);

  public static unsafe uint SaturatingIncrementByNumberOfWordElements(uint op, ulong imm_factor);

  public static unsafe ulong SaturatingIncrementByNumberOfWordElements(ulong op, ulong imm_factor);

  public static unsafe int SaturatingIncrementByNumberOfWordElements(int op, enum svpattern pattern, ulong imm_factor);

  public static unsafe long SaturatingIncrementByNumberOfWordElements(long op, enum svpattern pattern, ulong imm_factor);

  public static unsafe uint SaturatingIncrementByNumberOfWordElements(uint op, enum svpattern pattern, ulong imm_factor);

  public static unsafe ulong SaturatingIncrementByNumberOfWordElements(ulong op, enum svpattern pattern, ulong imm_factor);

  /// T: int, uint
  public static unsafe Vector<T> SaturatingIncrementByNumberOfWordElements(Vector<T> op, ulong imm_factor); // SQINCW or UQINCW (MOVPRFX)

  /// T: int, uint
  public static unsafe Vector<T> SaturatingIncrementByNumberOfWordElements(Vector<T> op, enum svpattern pattern, ulong imm_factor); // SQINCW or UQINCW (MOVPRFX)

  /// total method signatures: 101
}
Author: a74nh
Assignees: -
Labels:

area-System.Numerics, untriaged
Milestone: -

@a74nh
Copy link
Contributor Author

a74nh commented Oct 26, 2023 •
edited
Loading 

/// Full API
public abstract class Sve : AdvSimd /// Feature: FEAT_SVE  Category: counting
{
    /// Count16BitElements : Count the number of 16-bit elements in a vector

    /// uint64_t svcnth() : "CNTH Xresult, ALL"
  public static unsafe ulong Count16BitElements();

    /// uint64_t svcnth_pat(enum svpattern pattern) : "CNTH Xresult, pattern"
  public static unsafe ulong Count16BitElements(enum SveMaskPattern pattern);


    /// Count32BitElements : Count the number of 32-bit elements in a vector

    /// uint64_t svcntw() : "CNTW Xresult, ALL"
  public static unsafe ulong Count32BitElements();

    /// uint64_t svcntw_pat(enum svpattern pattern) : "CNTW Xresult, pattern"
  public static unsafe ulong Count32BitElements(enum SveMaskPattern pattern);


    /// Count64BitElements : Count the number of 64-bit elements in a vector

    /// uint64_t svcntd() : "CNTD Xresult, ALL"
  public static unsafe ulong Count64BitElements();

    /// uint64_t svcntd_pat(enum svpattern pattern) : "CNTD Xresult, pattern"
  public static unsafe ulong Count64BitElements(enum SveMaskPattern pattern);


    /// Count8BitElements : Count the number of 8-bit elements in a vector

    /// uint64_t svcntb() : "CNTB Xresult, ALL"
  public static unsafe ulong Count8BitElements();

    /// uint64_t svcntb_pat(enum svpattern pattern) : "CNTB Xresult, pattern"
  public static unsafe ulong Count8BitElements(enum SveMaskPattern pattern);


    /// GetActiveElementCount : Count set predicate bits

    /// uint64_t svcntp_b8(svbool_t pg, svbool_t op) : "CNTP Xresult, Pg, Pop.B"
  public static unsafe ulong GetActiveElementCount(Vector<byte> mask, Vector<byte> select);

    /// uint64_t svcntp_b16(svbool_t pg, svbool_t op) : "CNTP Xresult, Pg, Pop.H"
  public static unsafe ulong GetActiveElementCount(Vector<ushort> mask, Vector<ushort> select);

    /// uint64_t svcntp_b32(svbool_t pg, svbool_t op) : "CNTP Xresult, Pg, Pop.S"
  public static unsafe ulong GetActiveElementCount(Vector<uint> mask, Vector<uint> select);

    /// uint64_t svcntp_b64(svbool_t pg, svbool_t op) : "CNTP Xresult, Pg, Pop.D"
  public static unsafe ulong GetActiveElementCount(Vector<ulong> mask, Vector<ulong> select);


    /// LeadingSignCount : Count leading sign bits

    /// svuint8_t svcls[_s8]_m(svuint8_t inactive, svbool_t pg, svint8_t op) : "CLS Ztied.B, Pg/M, Zop.B" or "MOVPRFX Zresult, Zinactive; CLS Zresult.B, Pg/M, Zop.B"
    /// svuint8_t svcls[_s8]_x(svbool_t pg, svint8_t op) : "CLS Ztied.B, Pg/M, Ztied.B" or "MOVPRFX Zresult, Zop; CLS Zresult.B, Pg/M, Zop.B"
    /// svuint8_t svcls[_s8]_z(svbool_t pg, svint8_t op) : "MOVPRFX Zresult.B, Pg/Z, Zop.B; CLS Zresult.B, Pg/M, Zop.B"
  public static unsafe Vector<byte> LeadingSignCount(Vector<sbyte> value);

    /// svuint16_t svcls[_s16]_m(svuint16_t inactive, svbool_t pg, svint16_t op) : "CLS Ztied.H, Pg/M, Zop.H" or "MOVPRFX Zresult, Zinactive; CLS Zresult.H, Pg/M, Zop.H"
    /// svuint16_t svcls[_s16]_x(svbool_t pg, svint16_t op) : "CLS Ztied.H, Pg/M, Ztied.H" or "MOVPRFX Zresult, Zop; CLS Zresult.H, Pg/M, Zop.H"
    /// svuint16_t svcls[_s16]_z(svbool_t pg, svint16_t op) : "MOVPRFX Zresult.H, Pg/Z, Zop.H; CLS Zresult.H, Pg/M, Zop.H"
  public static unsafe Vector<ushort> LeadingSignCount(Vector<short> value);

    /// svuint32_t svcls[_s32]_m(svuint32_t inactive, svbool_t pg, svint32_t op) : "CLS Ztied.S, Pg/M, Zop.S" or "MOVPRFX Zresult, Zinactive; CLS Zresult.S, Pg/M, Zop.S"
    /// svuint32_t svcls[_s32]_x(svbool_t pg, svint32_t op) : "CLS Ztied.S, Pg/M, Ztied.S" or "MOVPRFX Zresult, Zop; CLS Zresult.S, Pg/M, Zop.S"
    /// svuint32_t svcls[_s32]_z(svbool_t pg, svint32_t op) : "MOVPRFX Zresult.S, Pg/Z, Zop.S; CLS Zresult.S, Pg/M, Zop.S"
  public static unsafe Vector<uint> LeadingSignCount(Vector<int> value);

    /// svuint64_t svcls[_s64]_m(svuint64_t inactive, svbool_t pg, svint64_t op) : "CLS Ztied.D, Pg/M, Zop.D" or "MOVPRFX Zresult, Zinactive; CLS Zresult.D, Pg/M, Zop.D"
    /// svuint64_t svcls[_s64]_x(svbool_t pg, svint64_t op) : "CLS Ztied.D, Pg/M, Ztied.D" or "MOVPRFX Zresult, Zop; CLS Zresult.D, Pg/M, Zop.D"
    /// svuint64_t svcls[_s64]_z(svbool_t pg, svint64_t op) : "MOVPRFX Zresult.D, Pg/Z, Zop.D; CLS Zresult.D, Pg/M, Zop.D"
  public static unsafe Vector<ulong> LeadingSignCount(Vector<long> value);


    /// LeadingZeroCount : Count leading zero bits

    /// svuint8_t svclz[_s8]_m(svuint8_t inactive, svbool_t pg, svint8_t op) : "CLZ Ztied.B, Pg/M, Zop.B" or "MOVPRFX Zresult, Zinactive; CLZ Zresult.B, Pg/M, Zop.B"
    /// svuint8_t svclz[_s8]_x(svbool_t pg, svint8_t op) : "CLZ Ztied.B, Pg/M, Ztied.B" or "MOVPRFX Zresult, Zop; CLZ Zresult.B, Pg/M, Zop.B"
    /// svuint8_t svclz[_s8]_z(svbool_t pg, svint8_t op) : "MOVPRFX Zresult.B, Pg/Z, Zop.B; CLZ Zresult.B, Pg/M, Zop.B"
  public static unsafe Vector<byte> LeadingZeroCount(Vector<sbyte> value);

    /// svuint16_t svclz[_s16]_m(svuint16_t inactive, svbool_t pg, svint16_t op) : "CLZ Ztied.H, Pg/M, Zop.H" or "MOVPRFX Zresult, Zinactive; CLZ Zresult.H, Pg/M, Zop.H"
    /// svuint16_t svclz[_s16]_x(svbool_t pg, svint16_t op) : "CLZ Ztied.H, Pg/M, Ztied.H" or "MOVPRFX Zresult, Zop; CLZ Zresult.H, Pg/M, Zop.H"
    /// svuint16_t svclz[_s16]_z(svbool_t pg, svint16_t op) : "MOVPRFX Zresult.H, Pg/Z, Zop.H; CLZ Zresult.H, Pg/M, Zop.H"
  public static unsafe Vector<ushort> LeadingZeroCount(Vector<short> value);

    /// svuint32_t svclz[_s32]_m(svuint32_t inactive, svbool_t pg, svint32_t op) : "CLZ Ztied.S, Pg/M, Zop.S" or "MOVPRFX Zresult, Zinactive; CLZ Zresult.S, Pg/M, Zop.S"
    /// svuint32_t svclz[_s32]_x(svbool_t pg, svint32_t op) : "CLZ Ztied.S, Pg/M, Ztied.S" or "MOVPRFX Zresult, Zop; CLZ Zresult.S, Pg/M, Zop.S"
    /// svuint32_t svclz[_s32]_z(svbool_t pg, svint32_t op) : "MOVPRFX Zresult.S, Pg/Z, Zop.S; CLZ Zresult.S, Pg/M, Zop.S"
  public static unsafe Vector<uint> LeadingZeroCount(Vector<int> value);

    /// svuint64_t svclz[_s64]_m(svuint64_t inactive, svbool_t pg, svint64_t op) : "CLZ Ztied.D, Pg/M, Zop.D" or "MOVPRFX Zresult, Zinactive; CLZ Zresult.D, Pg/M, Zop.D"
    /// svuint64_t svclz[_s64]_x(svbool_t pg, svint64_t op) : "CLZ Ztied.D, Pg/M, Ztied.D" or "MOVPRFX Zresult, Zop; CLZ Zresult.D, Pg/M, Zop.D"
    /// svuint64_t svclz[_s64]_z(svbool_t pg, svint64_t op) : "MOVPRFX Zresult.D, Pg/Z, Zop.D; CLZ Zresult.D, Pg/M, Zop.D"
  public static unsafe Vector<ulong> LeadingZeroCount(Vector<long> value);

    /// svuint8_t svclz[_u8]_m(svuint8_t inactive, svbool_t pg, svuint8_t op) : "CLZ Ztied.B, Pg/M, Zop.B" or "MOVPRFX Zresult, Zinactive; CLZ Zresult.B, Pg/M, Zop.B"
    /// svuint8_t svclz[_u8]_x(svbool_t pg, svuint8_t op) : "CLZ Ztied.B, Pg/M, Ztied.B" or "MOVPRFX Zresult, Zop; CLZ Zresult.B, Pg/M, Zop.B"
    /// svuint8_t svclz[_u8]_z(svbool_t pg, svuint8_t op) : "MOVPRFX Zresult.B, Pg/Z, Zop.B; CLZ Zresult.B, Pg/M, Zop.B"
  public static unsafe Vector<byte> LeadingZeroCount(Vector<byte> value);

    /// svuint16_t svclz[_u16]_m(svuint16_t inactive, svbool_t pg, svuint16_t op) : "CLZ Ztied.H, Pg/M, Zop.H" or "MOVPRFX Zresult, Zinactive; CLZ Zresult.H, Pg/M, Zop.H"
    /// svuint16_t svclz[_u16]_x(svbool_t pg, svuint16_t op) : "CLZ Ztied.H, Pg/M, Ztied.H" or "MOVPRFX Zresult, Zop; CLZ Zresult.H, Pg/M, Zop.H"
    /// svuint16_t svclz[_u16]_z(svbool_t pg, svuint16_t op) : "MOVPRFX Zresult.H, Pg/Z, Zop.H; CLZ Zresult.H, Pg/M, Zop.H"
  public static unsafe Vector<ushort> LeadingZeroCount(Vector<ushort> value);

    /// svuint32_t svclz[_u32]_m(svuint32_t inactive, svbool_t pg, svuint32_t op) : "CLZ Ztied.S, Pg/M, Zop.S" or "MOVPRFX Zresult, Zinactive; CLZ Zresult.S, Pg/M, Zop.S"
    /// svuint32_t svclz[_u32]_x(svbool_t pg, svuint32_t op) : "CLZ Ztied.S, Pg/M, Ztied.S" or "MOVPRFX Zresult, Zop; CLZ Zresult.S, Pg/M, Zop.S"
    /// svuint32_t svclz[_u32]_z(svbool_t pg, svuint32_t op) : "MOVPRFX Zresult.S, Pg/Z, Zop.S; CLZ Zresult.S, Pg/M, Zop.S"
  public static unsafe Vector<uint> LeadingZeroCount(Vector<uint> value);

    /// svuint64_t svclz[_u64]_m(svuint64_t inactive, svbool_t pg, svuint64_t op) : "CLZ Ztied.D, Pg/M, Zop.D" or "MOVPRFX Zresult, Zinactive; CLZ Zresult.D, Pg/M, Zop.D"
    /// svuint64_t svclz[_u64]_x(svbool_t pg, svuint64_t op) : "CLZ Ztied.D, Pg/M, Ztied.D" or "MOVPRFX Zresult, Zop; CLZ Zresult.D, Pg/M, Zop.D"
    /// svuint64_t svclz[_u64]_z(svbool_t pg, svuint64_t op) : "MOVPRFX Zresult.D, Pg/Z, Zop.D; CLZ Zresult.D, Pg/M, Zop.D"
  public static unsafe Vector<ulong> LeadingZeroCount(Vector<ulong> value);


    /// PopCount : Count nonzero bits

    /// svuint32_t svcnt[_f32]_m(svuint32_t inactive, svbool_t pg, svfloat32_t op) : "CNT Ztied.S, Pg/M, Zop.S" or "MOVPRFX Zresult, Zinactive; CNT Zresult.S, Pg/M, Zop.S"
    /// svuint32_t svcnt[_f32]_x(svbool_t pg, svfloat32_t op) : "CNT Ztied.S, Pg/M, Ztied.S" or "MOVPRFX Zresult, Zop; CNT Zresult.S, Pg/M, Zop.S"
    /// svuint32_t svcnt[_f32]_z(svbool_t pg, svfloat32_t op) : "MOVPRFX Zresult.S, Pg/Z, Zop.S; CNT Zresult.S, Pg/M, Zop.S"
  public static unsafe Vector<uint> PopCount(Vector<float> value);

    /// svuint64_t svcnt[_f64]_m(svuint64_t inactive, svbool_t pg, svfloat64_t op) : "CNT Ztied.D, Pg/M, Zop.D" or "MOVPRFX Zresult, Zinactive; CNT Zresult.D, Pg/M, Zop.D"
    /// svuint64_t svcnt[_f64]_x(svbool_t pg, svfloat64_t op) : "CNT Ztied.D, Pg/M, Ztied.D" or "MOVPRFX Zresult, Zop; CNT Zresult.D, Pg/M, Zop.D"
    /// svuint64_t svcnt[_f64]_z(svbool_t pg, svfloat64_t op) : "MOVPRFX Zresult.D, Pg/Z, Zop.D; CNT Zresult.D, Pg/M, Zop.D"
  public static unsafe Vector<ulong> PopCount(Vector<double> value);

    /// svuint8_t svcnt[_s8]_m(svuint8_t inactive, svbool_t pg, svint8_t op) : "CNT Ztied.B, Pg/M, Zop.B" or "MOVPRFX Zresult, Zinactive; CNT Zresult.B, Pg/M, Zop.B"
    /// svuint8_t svcnt[_s8]_x(svbool_t pg, svint8_t op) : "CNT Ztied.B, Pg/M, Ztied.B" or "MOVPRFX Zresult, Zop; CNT Zresult.B, Pg/M, Zop.B"
    /// svuint8_t svcnt[_s8]_z(svbool_t pg, svint8_t op) : "MOVPRFX Zresult.B, Pg/Z, Zop.B; CNT Zresult.B, Pg/M, Zop.B"
  public static unsafe Vector<byte> PopCount(Vector<sbyte> value);

    /// svuint16_t svcnt[_s16]_m(svuint16_t inactive, svbool_t pg, svint16_t op) : "CNT Ztied.H, Pg/M, Zop.H" or "MOVPRFX Zresult, Zinactive; CNT Zresult.H, Pg/M, Zop.H"
    /// svuint16_t svcnt[_s16]_x(svbool_t pg, svint16_t op) : "CNT Ztied.H, Pg/M, Ztied.H" or "MOVPRFX Zresult, Zop; CNT Zresult.H, Pg/M, Zop.H"
    /// svuint16_t svcnt[_s16]_z(svbool_t pg, svint16_t op) : "MOVPRFX Zresult.H, Pg/Z, Zop.H; CNT Zresult.H, Pg/M, Zop.H"
  public static unsafe Vector<ushort> PopCount(Vector<short> value);

    /// svuint32_t svcnt[_s32]_m(svuint32_t inactive, svbool_t pg, svint32_t op) : "CNT Ztied.S, Pg/M, Zop.S" or "MOVPRFX Zresult, Zinactive; CNT Zresult.S, Pg/M, Zop.S"
    /// svuint32_t svcnt[_s32]_x(svbool_t pg, svint32_t op) : "CNT Ztied.S, Pg/M, Ztied.S" or "MOVPRFX Zresult, Zop; CNT Zresult.S, Pg/M, Zop.S"
    /// svuint32_t svcnt[_s32]_z(svbool_t pg, svint32_t op) : "MOVPRFX Zresult.S, Pg/Z, Zop.S; CNT Zresult.S, Pg/M, Zop.S"
  public static unsafe Vector<uint> PopCount(Vector<int> value);

    /// svuint64_t svcnt[_s64]_m(svuint64_t inactive, svbool_t pg, svint64_t op) : "CNT Ztied.D, Pg/M, Zop.D" or "MOVPRFX Zresult, Zinactive; CNT Zresult.D, Pg/M, Zop.D"
    /// svuint64_t svcnt[_s64]_x(svbool_t pg, svint64_t op) : "CNT Ztied.D, Pg/M, Ztied.D" or "MOVPRFX Zresult, Zop; CNT Zresult.D, Pg/M, Zop.D"
    /// svuint64_t svcnt[_s64]_z(svbool_t pg, svint64_t op) : "MOVPRFX Zresult.D, Pg/Z, Zop.D; CNT Zresult.D, Pg/M, Zop.D"
  public static unsafe Vector<ulong> PopCount(Vector<long> value);

    /// svuint8_t svcnt[_u8]_m(svuint8_t inactive, svbool_t pg, svuint8_t op) : "CNT Ztied.B, Pg/M, Zop.B" or "MOVPRFX Zresult, Zinactive; CNT Zresult.B, Pg/M, Zop.B"
    /// svuint8_t svcnt[_u8]_x(svbool_t pg, svuint8_t op) : "CNT Ztied.B, Pg/M, Ztied.B" or "MOVPRFX Zresult, Zop; CNT Zresult.B, Pg/M, Zop.B"
    /// svuint8_t svcnt[_u8]_z(svbool_t pg, svuint8_t op) : "MOVPRFX Zresult.B, Pg/Z, Zop.B; CNT Zresult.B, Pg/M, Zop.B"
  public static unsafe Vector<byte> PopCount(Vector<byte> value);

    /// svuint16_t svcnt[_u16]_m(svuint16_t inactive, svbool_t pg, svuint16_t op) : "CNT Ztied.H, Pg/M, Zop.H" or "MOVPRFX Zresult, Zinactive; CNT Zresult.H, Pg/M, Zop.H"
    /// svuint16_t svcnt[_u16]_x(svbool_t pg, svuint16_t op) : "CNT Ztied.H, Pg/M, Ztied.H" or "MOVPRFX Zresult, Zop; CNT Zresult.H, Pg/M, Zop.H"
    /// svuint16_t svcnt[_u16]_z(svbool_t pg, svuint16_t op) : "MOVPRFX Zresult.H, Pg/Z, Zop.H; CNT Zresult.H, Pg/M, Zop.H"
  public static unsafe Vector<ushort> PopCount(Vector<ushort> value);

    /// svuint32_t svcnt[_u32]_m(svuint32_t inactive, svbool_t pg, svuint32_t op) : "CNT Ztied.S, Pg/M, Zop.S" or "MOVPRFX Zresult, Zinactive; CNT Zresult.S, Pg/M, Zop.S"
    /// svuint32_t svcnt[_u32]_x(svbool_t pg, svuint32_t op) : "CNT Ztied.S, Pg/M, Ztied.S" or "MOVPRFX Zresult, Zop; CNT Zresult.S, Pg/M, Zop.S"
    /// svuint32_t svcnt[_u32]_z(svbool_t pg, svuint32_t op) : "MOVPRFX Zresult.S, Pg/Z, Zop.S; CNT Zresult.S, Pg/M, Zop.S"
  public static unsafe Vector<uint> PopCount(Vector<uint> value);

    /// svuint64_t svcnt[_u64]_m(svuint64_t inactive, svbool_t pg, svuint64_t op) : "CNT Ztied.D, Pg/M, Zop.D" or "MOVPRFX Zresult, Zinactive; CNT Zresult.D, Pg/M, Zop.D"
    /// svuint64_t svcnt[_u64]_x(svbool_t pg, svuint64_t op) : "CNT Ztied.D, Pg/M, Ztied.D" or "MOVPRFX Zresult, Zop; CNT Zresult.D, Pg/M, Zop.D"
    /// svuint64_t svcnt[_u64]_z(svbool_t pg, svuint64_t op) : "MOVPRFX Zresult.D, Pg/Z, Zop.D; CNT Zresult.D, Pg/M, Zop.D"
  public static unsafe Vector<ulong> PopCount(Vector<ulong> value);


    /// SaturatingDecrementByActiveElementCount : Saturating decrement by active element count

    /// int32_t svqdecp[_n_s32]_b8(int32_t op, svbool_t pg) : "SQDECP Xtied, Pg.B, Wtied"
  public static unsafe int SaturatingDecrementByActiveElementCount(int op, Vector<byte> select);

    /// int32_t svqdecp[_n_s32]_b16(int32_t op, svbool_t pg) : "SQDECP Xtied, Pg.H, Wtied"
  public static unsafe int SaturatingDecrementByActiveElementCount(int op, Vector<ushort> select);

    /// int32_t svqdecp[_n_s32]_b32(int32_t op, svbool_t pg) : "SQDECP Xtied, Pg.S, Wtied"
  public static unsafe int SaturatingDecrementByActiveElementCount(int op, Vector<uint> select);

    /// int32_t svqdecp[_n_s32]_b64(int32_t op, svbool_t pg) : "SQDECP Xtied, Pg.D, Wtied"
  public static unsafe int SaturatingDecrementByActiveElementCount(int op, Vector<ulong> select);

    /// int64_t svqdecp[_n_s64]_b8(int64_t op, svbool_t pg) : "SQDECP Xtied, Pg.B"
  public static unsafe long SaturatingDecrementByActiveElementCount(long op, Vector<byte> select);

    /// int64_t svqdecp[_n_s64]_b16(int64_t op, svbool_t pg) : "SQDECP Xtied, Pg.H"
  public static unsafe long SaturatingDecrementByActiveElementCount(long op, Vector<ushort> select);

    /// int64_t svqdecp[_n_s64]_b32(int64_t op, svbool_t pg) : "SQDECP Xtied, Pg.S"
  public static unsafe long SaturatingDecrementByActiveElementCount(long op, Vector<uint> select);

    /// int64_t svqdecp[_n_s64]_b64(int64_t op, svbool_t pg) : "SQDECP Xtied, Pg.D"
  public static unsafe long SaturatingDecrementByActiveElementCount(long op, Vector<ulong> select);

    /// uint32_t svqdecp[_n_u32]_b8(uint32_t op, svbool_t pg) : "UQDECP Wtied, Pg.B"
  public static unsafe uint SaturatingDecrementByActiveElementCount(uint op, Vector<byte> select);

    /// uint32_t svqdecp[_n_u32]_b16(uint32_t op, svbool_t pg) : "UQDECP Wtied, Pg.H"
  public static unsafe uint SaturatingDecrementByActiveElementCount(uint op, Vector<ushort> select);

    /// uint32_t svqdecp[_n_u32]_b32(uint32_t op, svbool_t pg) : "UQDECP Wtied, Pg.S"
  public static unsafe uint SaturatingDecrementByActiveElementCount(uint op, Vector<uint> select);

    /// uint32_t svqdecp[_n_u32]_b64(uint32_t op, svbool_t pg) : "UQDECP Wtied, Pg.D"
  public static unsafe uint SaturatingDecrementByActiveElementCount(uint op, Vector<ulong> select);

    /// uint64_t svqdecp[_n_u64]_b8(uint64_t op, svbool_t pg) : "UQDECP Xtied, Pg.B"
  public static unsafe ulong SaturatingDecrementByActiveElementCount(ulong op, Vector<byte> select);

    /// uint64_t svqdecp[_n_u64]_b16(uint64_t op, svbool_t pg) : "UQDECP Xtied, Pg.H"
  public static unsafe ulong SaturatingDecrementByActiveElementCount(ulong op, Vector<ushort> select);

    /// uint64_t svqdecp[_n_u64]_b32(uint64_t op, svbool_t pg) : "UQDECP Xtied, Pg.S"
  public static unsafe ulong SaturatingDecrementByActiveElementCount(ulong op, Vector<uint> select);

    /// uint64_t svqdecp[_n_u64]_b64(uint64_t op, svbool_t pg) : "UQDECP Xtied, Pg.D"
  public static unsafe ulong SaturatingDecrementByActiveElementCount(ulong op, Vector<ulong> select);

    /// svint16_t svqdecp[_s16](svint16_t op, svbool_t pg) : "SQDECP Ztied.H, Pg" or "MOVPRFX Zresult, Zop; SQDECP Zresult.H, Pg"
  public static unsafe Vector<short> SaturatingDecrementByActiveElementCount(Vector<short> op, Vector<short> select);

    /// svint32_t svqdecp[_s32](svint32_t op, svbool_t pg) : "SQDECP Ztied.S, Pg" or "MOVPRFX Zresult, Zop; SQDECP Zresult.S, Pg"
  public static unsafe Vector<int> SaturatingDecrementByActiveElementCount(Vector<int> op, Vector<int> select);

    /// svint64_t svqdecp[_s64](svint64_t op, svbool_t pg) : "SQDECP Ztied.D, Pg" or "MOVPRFX Zresult, Zop; SQDECP Zresult.D, Pg"
  public static unsafe Vector<long> SaturatingDecrementByActiveElementCount(Vector<long> op, Vector<long> select);

    /// svuint16_t svqdecp[_u16](svuint16_t op, svbool_t pg) : "UQDECP Ztied.H, Pg" or "MOVPRFX Zresult, Zop; UQDECP Zresult.H, Pg"
  public static unsafe Vector<ushort> SaturatingDecrementByActiveElementCount(Vector<ushort> op, Vector<ushort> select);

    /// svuint32_t svqdecp[_u32](svuint32_t op, svbool_t pg) : "UQDECP Ztied.S, Pg" or "MOVPRFX Zresult, Zop; UQDECP Zresult.S, Pg"
  public static unsafe Vector<uint> SaturatingDecrementByActiveElementCount(Vector<uint> op, Vector<uint> select);

    /// svuint64_t svqdecp[_u64](svuint64_t op, svbool_t pg) : "UQDECP Ztied.D, Pg" or "MOVPRFX Zresult, Zop; UQDECP Zresult.D, Pg"
  public static unsafe Vector<ulong> SaturatingDecrementByActiveElementCount(Vector<ulong> op, Vector<ulong> select);


    /// SaturatingDecrementByteElementCount : Saturating decrement by number of byte elements

    /// int32_t svqdecb[_n_s32](int32_t op, uint64_t imm_factor) : "SQDECB Xtied, Wtied, ALL, MUL #imm_factor"
  public static unsafe int SaturatingDecrementByteElementCount(int op, ulong imm_factor);

    /// int64_t svqdecb[_n_s64](int64_t op, uint64_t imm_factor) : "SQDECB Xtied, ALL, MUL #imm_factor"
  public static unsafe long SaturatingDecrementByteElementCount(long op, ulong imm_factor);

    /// uint32_t svqdecb[_n_u32](uint32_t op, uint64_t imm_factor) : "UQDECB Wtied, ALL, MUL #imm_factor"
  public static unsafe uint SaturatingDecrementByteElementCount(uint op, ulong imm_factor);

    /// uint64_t svqdecb[_n_u64](uint64_t op, uint64_t imm_factor) : "UQDECB Xtied, ALL, MUL #imm_factor"
  public static unsafe ulong SaturatingDecrementByteElementCount(ulong op, ulong imm_factor);

    /// int32_t svqdecb_pat[_n_s32](int32_t op, enum svpattern pattern, uint64_t imm_factor) : "SQDECB Xtied, Wtied, pattern, MUL #imm_factor"
  public static unsafe int SaturatingDecrementByteElementCount(int op, enum SveMaskPattern pattern, ulong imm_factor);

    /// int64_t svqdecb_pat[_n_s64](int64_t op, enum svpattern pattern, uint64_t imm_factor) : "SQDECB Xtied, pattern, MUL #imm_factor"
  public static unsafe long SaturatingDecrementByteElementCount(long op, enum SveMaskPattern pattern, ulong imm_factor);

    /// uint32_t svqdecb_pat[_n_u32](uint32_t op, enum svpattern pattern, uint64_t imm_factor) : "UQDECB Wtied, pattern, MUL #imm_factor"
  public static unsafe uint SaturatingDecrementByteElementCount(uint op, enum SveMaskPattern pattern, ulong imm_factor);

    /// uint64_t svqdecb_pat[_n_u64](uint64_t op, enum svpattern pattern, uint64_t imm_factor) : "UQDECB Xtied, pattern, MUL #imm_factor"
  public static unsafe ulong SaturatingDecrementByteElementCount(ulong op, enum SveMaskPattern pattern, ulong imm_factor);


    /// SaturatingDecrementInt16ElementCount : Saturating decrement by number of halfword elements

    /// int32_t svqdech[_n_s32](int32_t op, uint64_t imm_factor) : "SQDECH Xtied, Wtied, ALL, MUL #imm_factor"
  public static unsafe int SaturatingDecrementInt16ElementCount(int op, ulong imm_factor);

    /// int64_t svqdech[_n_s64](int64_t op, uint64_t imm_factor) : "SQDECH Xtied, ALL, MUL #imm_factor"
  public static unsafe long SaturatingDecrementInt16ElementCount(long op, ulong imm_factor);

    /// uint32_t svqdech[_n_u32](uint32_t op, uint64_t imm_factor) : "UQDECH Wtied, ALL, MUL #imm_factor"
  public static unsafe uint SaturatingDecrementInt16ElementCount(uint op, ulong imm_factor);

    /// uint64_t svqdech[_n_u64](uint64_t op, uint64_t imm_factor) : "UQDECH Xtied, ALL, MUL #imm_factor"
  public static unsafe ulong SaturatingDecrementInt16ElementCount(ulong op, ulong imm_factor);

    /// int32_t svqdech_pat[_n_s32](int32_t op, enum svpattern pattern, uint64_t imm_factor) : "SQDECH Xtied, Wtied, pattern, MUL #imm_factor"
  public static unsafe int SaturatingDecrementInt16ElementCount(int op, enum SveMaskPattern pattern, ulong imm_factor);

    /// int64_t svqdech_pat[_n_s64](int64_t op, enum svpattern pattern, uint64_t imm_factor) : "SQDECH Xtied, pattern, MUL #imm_factor"
  public static unsafe long SaturatingDecrementInt16ElementCount(long op, enum SveMaskPattern pattern, ulong imm_factor);

    /// uint32_t svqdech_pat[_n_u32](uint32_t op, enum svpattern pattern, uint64_t imm_factor) : "UQDECH Wtied, pattern, MUL #imm_factor"
  public static unsafe uint SaturatingDecrementInt16ElementCount(uint op, enum SveMaskPattern pattern, ulong imm_factor);

    /// uint64_t svqdech_pat[_n_u64](uint64_t op, enum svpattern pattern, uint64_t imm_factor) : "UQDECH Xtied, pattern, MUL #imm_factor"
  public static unsafe ulong SaturatingDecrementInt16ElementCount(ulong op, enum SveMaskPattern pattern, ulong imm_factor);

    /// svint16_t svqdech[_s16](svint16_t op, uint64_t imm_factor) : "SQDECH Ztied.H, ALL, MUL #imm_factor" or "MOVPRFX Zresult, Zop; SQDECH Zresult.H, ALL, MUL #imm_factor"
  public static unsafe Vector<short> SaturatingDecrementInt16ElementCount(Vector<short> op, ulong imm_factor);

    /// svuint16_t svqdech[_u16](svuint16_t op, uint64_t imm_factor) : "UQDECH Ztied.H, ALL, MUL #imm_factor" or "MOVPRFX Zresult, Zop; UQDECH Zresult.H, ALL, MUL #imm_factor"
  public static unsafe Vector<ushort> SaturatingDecrementInt16ElementCount(Vector<ushort> op, ulong imm_factor);

    /// svint16_t svqdech_pat[_s16](svint16_t op, enum svpattern pattern, uint64_t imm_factor) : "SQDECH Ztied.H, pattern, MUL #imm_factor" or "MOVPRFX Zresult, Zop; SQDECH Zresult.H, pattern, MUL #imm_factor"
  public static unsafe Vector<short> SaturatingDecrementInt16ElementCount(Vector<short> op, enum SveMaskPattern pattern, ulong imm_factor);

    /// svuint16_t svqdech_pat[_u16](svuint16_t op, enum svpattern pattern, uint64_t imm_factor) : "UQDECH Ztied.H, pattern, MUL #imm_factor" or "MOVPRFX Zresult, Zop; UQDECH Zresult.H, pattern, MUL #imm_factor"
  public static unsafe Vector<ushort> SaturatingDecrementInt16ElementCount(Vector<ushort> op, enum SveMaskPattern pattern, ulong imm_factor);


    /// SaturatingDecrementInt32ElementCount : Saturating decrement by number of word elements

    /// int32_t svqdecw[_n_s32](int32_t op, uint64_t imm_factor) : "SQDECW Xtied, Wtied, ALL, MUL #imm_factor"
  public static unsafe int SaturatingDecrementInt32ElementCount(int op, ulong imm_factor);

    /// int64_t svqdecw[_n_s64](int64_t op, uint64_t imm_factor) : "SQDECW Xtied, ALL, MUL #imm_factor"
  public static unsafe long SaturatingDecrementInt32ElementCount(long op, ulong imm_factor);

    /// uint32_t svqdecw[_n_u32](uint32_t op, uint64_t imm_factor) : "UQDECW Wtied, ALL, MUL #imm_factor"
  public static unsafe uint SaturatingDecrementInt32ElementCount(uint op, ulong imm_factor);

    /// uint64_t svqdecw[_n_u64](uint64_t op, uint64_t imm_factor) : "UQDECW Xtied, ALL, MUL #imm_factor"
  public static unsafe ulong SaturatingDecrementInt32ElementCount(ulong op, ulong imm_factor);

    /// int32_t svqdecw_pat[_n_s32](int32_t op, enum svpattern pattern, uint64_t imm_factor) : "SQDECW Xtied, Wtied, pattern, MUL #imm_factor"
  public static unsafe int SaturatingDecrementInt32ElementCount(int op, enum SveMaskPattern pattern, ulong imm_factor);

    /// int64_t svqdecw_pat[_n_s64](int64_t op, enum svpattern pattern, uint64_t imm_factor) : "SQDECW Xtied, pattern, MUL #imm_factor"
  public static unsafe long SaturatingDecrementInt32ElementCount(long op, enum SveMaskPattern pattern, ulong imm_factor);

    /// uint32_t svqdecw_pat[_n_u32](uint32_t op, enum svpattern pattern, uint64_t imm_factor) : "UQDECW Wtied, pattern, MUL #imm_factor"
  public static unsafe uint SaturatingDecrementInt32ElementCount(uint op, enum SveMaskPattern pattern, ulong imm_factor);

    /// uint64_t svqdecw_pat[_n_u64](uint64_t op, enum svpattern pattern, uint64_t imm_factor) : "UQDECW Xtied, pattern, MUL #imm_factor"
  public static unsafe ulong SaturatingDecrementInt32ElementCount(ulong op, enum SveMaskPattern pattern, ulong imm_factor);

    /// svint32_t svqdecw[_s32](svint32_t op, uint64_t imm_factor) : "SQDECW Ztied.S, ALL, MUL #imm_factor" or "MOVPRFX Zresult, Zop; SQDECW Zresult.S, ALL, MUL #imm_factor"
  public static unsafe Vector<int> SaturatingDecrementInt32ElementCount(Vector<int> op, ulong imm_factor);

    /// svuint32_t svqdecw[_u32](svuint32_t op, uint64_t imm_factor) : "UQDECW Ztied.S, ALL, MUL #imm_factor" or "MOVPRFX Zresult, Zop; UQDECW Zresult.S, ALL, MUL #imm_factor"
  public static unsafe Vector<uint> SaturatingDecrementInt32ElementCount(Vector<uint> op, ulong imm_factor);

    /// svint32_t svqdecw_pat[_s32](svint32_t op, enum svpattern pattern, uint64_t imm_factor) : "SQDECW Ztied.S, pattern, MUL #imm_factor" or "MOVPRFX Zresult, Zop; SQDECW Zresult.S, pattern, MUL #imm_factor"
  public static unsafe Vector<int> SaturatingDecrementInt32ElementCount(Vector<int> op, enum SveMaskPattern pattern, ulong imm_factor);

    /// svuint32_t svqdecw_pat[_u32](svuint32_t op, enum svpattern pattern, uint64_t imm_factor) : "UQDECW Ztied.S, pattern, MUL #imm_factor" or "MOVPRFX Zresult, Zop; UQDECW Zresult.S, pattern, MUL #imm_factor"
  public static unsafe Vector<uint> SaturatingDecrementInt32ElementCount(Vector<uint> op, enum SveMaskPattern pattern, ulong imm_factor);


    /// SaturatingDecrementInt64ElementCount : Saturating decrement by number of doubleword elements

    /// int32_t svqdecd[_n_s32](int32_t op, uint64_t imm_factor) : "SQDECD Xtied, Wtied, ALL, MUL #imm_factor"
  public static unsafe int SaturatingDecrementInt64ElementCount(int op, ulong imm_factor);

    /// int64_t svqdecd[_n_s64](int64_t op, uint64_t imm_factor) : "SQDECD Xtied, ALL, MUL #imm_factor"
  public static unsafe long SaturatingDecrementInt64ElementCount(long op, ulong imm_factor);

    /// uint32_t svqdecd[_n_u32](uint32_t op, uint64_t imm_factor) : "UQDECD Wtied, ALL, MUL #imm_factor"
  public static unsafe uint SaturatingDecrementInt64ElementCount(uint op, ulong imm_factor);

    /// uint64_t svqdecd[_n_u64](uint64_t op, uint64_t imm_factor) : "UQDECD Xtied, ALL, MUL #imm_factor"
  public static unsafe ulong SaturatingDecrementInt64ElementCount(ulong op, ulong imm_factor);

    /// int32_t svqdecd_pat[_n_s32](int32_t op, enum svpattern pattern, uint64_t imm_factor) : "SQDECD Xtied, Wtied, pattern, MUL #imm_factor"
  public static unsafe int SaturatingDecrementInt64ElementCount(int op, enum SveMaskPattern pattern, ulong imm_factor);

    /// int64_t svqdecd_pat[_n_s64](int64_t op, enum svpattern pattern, uint64_t imm_factor) : "SQDECD Xtied, pattern, MUL #imm_factor"
  public static unsafe long SaturatingDecrementInt64ElementCount(long op, enum SveMaskPattern pattern, ulong imm_factor);

    /// uint32_t svqdecd_pat[_n_u32](uint32_t op, enum svpattern pattern, uint64_t imm_factor) : "UQDECD Wtied, pattern, MUL #imm_factor"
  public static unsafe uint SaturatingDecrementInt64ElementCount(uint op, enum SveMaskPattern pattern, ulong imm_factor);

    /// uint64_t svqdecd_pat[_n_u64](uint64_t op, enum svpattern pattern, uint64_t imm_factor) : "UQDECD Xtied, pattern, MUL #imm_factor"
  public static unsafe ulong SaturatingDecrementInt64ElementCount(ulong op, enum SveMaskPattern pattern, ulong imm_factor);

    /// svint64_t svqdecd[_s64](svint64_t op, uint64_t imm_factor) : "SQDECD Ztied.D, ALL, MUL #imm_factor" or "MOVPRFX Zresult, Zop; SQDECD Zresult.D, ALL, MUL #imm_factor"
  public static unsafe Vector<long> SaturatingDecrementInt64ElementCount(Vector<long> op, ulong imm_factor);

    /// svuint64_t svqdecd[_u64](svuint64_t op, uint64_t imm_factor) : "UQDECD Ztied.D, ALL, MUL #imm_factor" or "MOVPRFX Zresult, Zop; UQDECD Zresult.D, ALL, MUL #imm_factor"
  public static unsafe Vector<ulong> SaturatingDecrementInt64ElementCount(Vector<ulong> op, ulong imm_factor);

    /// svint64_t svqdecd_pat[_s64](svint64_t op, enum svpattern pattern, uint64_t imm_factor) : "SQDECD Ztied.D, pattern, MUL #imm_factor" or "MOVPRFX Zresult, Zop; SQDECD Zresult.D, pattern, MUL #imm_factor"
  public static unsafe Vector<long> SaturatingDecrementInt64ElementCount(Vector<long> op, enum SveMaskPattern pattern, ulong imm_factor);

    /// svuint64_t svqdecd_pat[_u64](svuint64_t op, enum svpattern pattern, uint64_t imm_factor) : "UQDECD Ztied.D, pattern, MUL #imm_factor" or "MOVPRFX Zresult, Zop; UQDECD Zresult.D, pattern, MUL #imm_factor"
  public static unsafe Vector<ulong> SaturatingDecrementInt64ElementCount(Vector<ulong> op, enum SveMaskPattern pattern, ulong imm_factor);


    /// SaturatingIncrementByActiveElementCount : Saturating increment by active element count

    /// int32_t svqincp[_n_s32]_b8(int32_t op, svbool_t pg) : "SQINCP Xtied, Pg.B, Wtied"
  public static unsafe int SaturatingIncrementByActiveElementCount(int op, Vector<byte> select);

    /// int32_t svqincp[_n_s32]_b16(int32_t op, svbool_t pg) : "SQINCP Xtied, Pg.H, Wtied"
  public static unsafe int SaturatingIncrementByActiveElementCount(int op, Vector<ushort> select);

    /// int32_t svqincp[_n_s32]_b32(int32_t op, svbool_t pg) : "SQINCP Xtied, Pg.S, Wtied"
  public static unsafe int SaturatingIncrementByActiveElementCount(int op, Vector<uint> select);

    /// int32_t svqincp[_n_s32]_b64(int32_t op, svbool_t pg) : "SQINCP Xtied, Pg.D, Wtied"
  public static unsafe int SaturatingIncrementByActiveElementCount(int op, Vector<ulong> select);

    /// int64_t svqincp[_n_s64]_b8(int64_t op, svbool_t pg) : "SQINCP Xtied, Pg.B"
  public static unsafe long SaturatingIncrementByActiveElementCount(long op, Vector<byte> select);

    /// int64_t svqincp[_n_s64]_b16(int64_t op, svbool_t pg) : "SQINCP Xtied, Pg.H"
  public static unsafe long SaturatingIncrementByActiveElementCount(long op, Vector<ushort> select);

    /// int64_t svqincp[_n_s64]_b32(int64_t op, svbool_t pg) : "SQINCP Xtied, Pg.S"
  public static unsafe long SaturatingIncrementByActiveElementCount(long op, Vector<uint> select);

    /// int64_t svqincp[_n_s64]_b64(int64_t op, svbool_t pg) : "SQINCP Xtied, Pg.D"
  public static unsafe long SaturatingIncrementByActiveElementCount(long op, Vector<ulong> select);

    /// uint32_t svqincp[_n_u32]_b8(uint32_t op, svbool_t pg) : "UQINCP Wtied, Pg.B"
  public static unsafe uint SaturatingIncrementByActiveElementCount(uint op, Vector<byte> select);

    /// uint32_t svqincp[_n_u32]_b16(uint32_t op, svbool_t pg) : "UQINCP Wtied, Pg.H"
  public static unsafe uint SaturatingIncrementByActiveElementCount(uint op, Vector<ushort> select);

    /// uint32_t svqincp[_n_u32]_b32(uint32_t op, svbool_t pg) : "UQINCP Wtied, Pg.S"
  public static unsafe uint SaturatingIncrementByActiveElementCount(uint op, Vector<uint> select);

    /// uint32_t svqincp[_n_u32]_b64(uint32_t op, svbool_t pg) : "UQINCP Wtied, Pg.D"
  public static unsafe uint SaturatingIncrementByActiveElementCount(uint op, Vector<ulong> select);

    /// uint64_t svqincp[_n_u64]_b8(uint64_t op, svbool_t pg) : "UQINCP Xtied, Pg.B"
  public static unsafe ulong SaturatingIncrementByActiveElementCount(ulong op, Vector<byte> select);

    /// uint64_t svqincp[_n_u64]_b16(uint64_t op, svbool_t pg) : "UQINCP Xtied, Pg.H"
  public static unsafe ulong SaturatingIncrementByActiveElementCount(ulong op, Vector<ushort> select);

    /// uint64_t svqincp[_n_u64]_b32(uint64_t op, svbool_t pg) : "UQINCP Xtied, Pg.S"
  public static unsafe ulong SaturatingIncrementByActiveElementCount(ulong op, Vector<uint> select);

    /// uint64_t svqincp[_n_u64]_b64(uint64_t op, svbool_t pg) : "UQINCP Xtied, Pg.D"
  public static unsafe ulong SaturatingIncrementByActiveElementCount(ulong op, Vector<ulong> select);

    /// svint16_t svqincp[_s16](svint16_t op, svbool_t pg) : "SQINCP Ztied.H, Pg" or "MOVPRFX Zresult, Zop; SQINCP Zresult.H, Pg"
  public static unsafe Vector<short> SaturatingIncrementByActiveElementCount(Vector<short> op, Vector<short> select);

    /// svint32_t svqincp[_s32](svint32_t op, svbool_t pg) : "SQINCP Ztied.S, Pg" or "MOVPRFX Zresult, Zop; SQINCP Zresult.S, Pg"
  public static unsafe Vector<int> SaturatingIncrementByActiveElementCount(Vector<int> op, Vector<int> select);

    /// svint64_t svqincp[_s64](svint64_t op, svbool_t pg) : "SQINCP Ztied.D, Pg" or "MOVPRFX Zresult, Zop; SQINCP Zresult.D, Pg"
  public static unsafe Vector<long> SaturatingIncrementByActiveElementCount(Vector<long> op, Vector<long> select);

    /// svuint16_t svqincp[_u16](svuint16_t op, svbool_t pg) : "UQINCP Ztied.H, Pg" or "MOVPRFX Zresult, Zop; UQINCP Zresult.H, Pg"
  public static unsafe Vector<ushort> SaturatingIncrementByActiveElementCount(Vector<ushort> op, Vector<ushort> select);

    /// svuint32_t svqincp[_u32](svuint32_t op, svbool_t pg) : "UQINCP Ztied.S, Pg" or "MOVPRFX Zresult, Zop; UQINCP Zresult.S, Pg"
  public static unsafe Vector<uint> SaturatingIncrementByActiveElementCount(Vector<uint> op, Vector<uint> select);

    /// svuint64_t svqincp[_u64](svuint64_t op, svbool_t pg) : "UQINCP Ztied.D, Pg" or "MOVPRFX Zresult, Zop; UQINCP Zresult.D, Pg"
  public static unsafe Vector<ulong> SaturatingIncrementByActiveElementCount(Vector<ulong> op, Vector<ulong> select);


    /// SaturatingIncrementByteElementCount : Saturating increment by number of byte elements

    /// int32_t svqincb[_n_s32](int32_t op, uint64_t imm_factor) : "SQINCB Xtied, Wtied, ALL, MUL #imm_factor"
  public static unsafe int SaturatingIncrementByteElementCount(int op, ulong imm_factor);

    /// int64_t svqincb[_n_s64](int64_t op, uint64_t imm_factor) : "SQINCB Xtied, ALL, MUL #imm_factor"
  public static unsafe long SaturatingIncrementByteElementCount(long op, ulong imm_factor);

    /// uint32_t svqincb[_n_u32](uint32_t op, uint64_t imm_factor) : "UQINCB Wtied, ALL, MUL #imm_factor"
  public static unsafe uint SaturatingIncrementByteElementCount(uint op, ulong imm_factor);

    /// uint64_t svqincb[_n_u64](uint64_t op, uint64_t imm_factor) : "UQINCB Xtied, ALL, MUL #imm_factor"
  public static unsafe ulong SaturatingIncrementByteElementCount(ulong op, ulong imm_factor);

    /// int32_t svqincb_pat[_n_s32](int32_t op, enum svpattern pattern, uint64_t imm_factor) : "SQINCB Xtied, Wtied, pattern, MUL #imm_factor"
  public static unsafe int SaturatingIncrementByteElementCount(int op, enum SveMaskPattern pattern, ulong imm_factor);

    /// int64_t svqincb_pat[_n_s64](int64_t op, enum svpattern pattern, uint64_t imm_factor) : "SQINCB Xtied, pattern, MUL #imm_factor"
  public static unsafe long SaturatingIncrementByteElementCount(long op, enum SveMaskPattern pattern, ulong imm_factor);

    /// uint32_t svqincb_pat[_n_u32](uint32_t op, enum svpattern pattern, uint64_t imm_factor) : "UQINCB Wtied, pattern, MUL #imm_factor"
  public static unsafe uint SaturatingIncrementByteElementCount(uint op, enum SveMaskPattern pattern, ulong imm_factor);

    /// uint64_t svqincb_pat[_n_u64](uint64_t op, enum svpattern pattern, uint64_t imm_factor) : "UQINCB Xtied, pattern, MUL #imm_factor"
  public static unsafe ulong SaturatingIncrementByteElementCount(ulong op, enum SveMaskPattern pattern, ulong imm_factor);


    /// SaturatingIncrementInt16ElementCount : Saturating increment by number of halfword elements

    /// int32_t svqinch[_n_s32](int32_t op, uint64_t imm_factor) : "SQINCH Xtied, Wtied, ALL, MUL #imm_factor"
  public static unsafe int SaturatingIncrementInt16ElementCount(int op, ulong imm_factor);

    /// int64_t svqinch[_n_s64](int64_t op, uint64_t imm_factor) : "SQINCH Xtied, ALL, MUL #imm_factor"
  public static unsafe long SaturatingIncrementInt16ElementCount(long op, ulong imm_factor);

    /// uint32_t svqinch[_n_u32](uint32_t op, uint64_t imm_factor) : "UQINCH Wtied, ALL, MUL #imm_factor"
  public static unsafe uint SaturatingIncrementInt16ElementCount(uint op, ulong imm_factor);

    /// uint64_t svqinch[_n_u64](uint64_t op, uint64_t imm_factor) : "UQINCH Xtied, ALL, MUL #imm_factor"
  public static unsafe ulong SaturatingIncrementInt16ElementCount(ulong op, ulong imm_factor);

    /// int32_t svqinch_pat[_n_s32](int32_t op, enum svpattern pattern, uint64_t imm_factor) : "SQINCH Xtied, Wtied, pattern, MUL #imm_factor"
  public static unsafe int SaturatingIncrementInt16ElementCount(int op, enum SveMaskPattern pattern, ulong imm_factor);

    /// int64_t svqinch_pat[_n_s64](int64_t op, enum svpattern pattern, uint64_t imm_factor) : "SQINCH Xtied, pattern, MUL #imm_factor"
  public static unsafe long SaturatingIncrementInt16ElementCount(long op, enum SveMaskPattern pattern, ulong imm_factor);

    /// uint32_t svqinch_pat[_n_u32](uint32_t op, enum svpattern pattern, uint64_t imm_factor) : "UQINCH Wtied, pattern, MUL #imm_factor"
  public static unsafe uint SaturatingIncrementInt16ElementCount(uint op, enum SveMaskPattern pattern, ulong imm_factor);

    /// uint64_t svqinch_pat[_n_u64](uint64_t op, enum svpattern pattern, uint64_t imm_factor) : "UQINCH Xtied, pattern, MUL #imm_factor"
  public static unsafe ulong SaturatingIncrementInt16ElementCount(ulong op, enum SveMaskPattern pattern, ulong imm_factor);

    /// svint16_t svqinch[_s16](svint16_t op, uint64_t imm_factor) : "SQINCH Ztied.H, ALL, MUL #imm_factor" or "MOVPRFX Zresult, Zop; SQINCH Zresult.H, ALL, MUL #imm_factor"
  public static unsafe Vector<short> SaturatingIncrementInt16ElementCount(Vector<short> op, ulong imm_factor);

    /// svuint16_t svqinch[_u16](svuint16_t op, uint64_t imm_factor) : "UQINCH Ztied.H, ALL, MUL #imm_factor" or "MOVPRFX Zresult, Zop; UQINCH Zresult.H, ALL, MUL #imm_factor"
  public static unsafe Vector<ushort> SaturatingIncrementInt16ElementCount(Vector<ushort> op, ulong imm_factor);

    /// svint16_t svqinch_pat[_s16](svint16_t op, enum svpattern pattern, uint64_t imm_factor) : "SQINCH Ztied.H, pattern, MUL #imm_factor" or "MOVPRFX Zresult, Zop; SQINCH Zresult.H, pattern, MUL #imm_factor"
  public static unsafe Vector<short> SaturatingIncrementInt16ElementCount(Vector<short> op, enum SveMaskPattern pattern, ulong imm_factor);

    /// svuint16_t svqinch_pat[_u16](svuint16_t op, enum svpattern pattern, uint64_t imm_factor) : "UQINCH Ztied.H, pattern, MUL #imm_factor" or "MOVPRFX Zresult, Zop; UQINCH Zresult.H, pattern, MUL #imm_factor"
  public static unsafe Vector<ushort> SaturatingIncrementInt16ElementCount(Vector<ushort> op, enum SveMaskPattern pattern, ulong imm_factor);


    /// SaturatingIncrementInt32ElementCount : Saturating increment by number of word elements

    /// int32_t svqincw[_n_s32](int32_t op, uint64_t imm_factor) : "SQINCW Xtied, Wtied, ALL, MUL #imm_factor"
  public static unsafe int SaturatingIncrementInt32ElementCount(int op, ulong imm_factor);

    /// int64_t svqincw[_n_s64](int64_t op, uint64_t imm_factor) : "SQINCW Xtied, ALL, MUL #imm_factor"
  public static unsafe long SaturatingIncrementInt32ElementCount(long op, ulong imm_factor);

    /// uint32_t svqincw[_n_u32](uint32_t op, uint64_t imm_factor) : "UQINCW Wtied, ALL, MUL #imm_factor"
  public static unsafe uint SaturatingIncrementInt32ElementCount(uint op, ulong imm_factor);

    /// uint64_t svqincw[_n_u64](uint64_t op, uint64_t imm_factor) : "UQINCW Xtied, ALL, MUL #imm_factor"
  public static unsafe ulong SaturatingIncrementInt32ElementCount(ulong op, ulong imm_factor);

    /// int32_t svqincw_pat[_n_s32](int32_t op, enum svpattern pattern, uint64_t imm_factor) : "SQINCW Xtied, Wtied, pattern, MUL #imm_factor"
  public static unsafe int SaturatingIncrementInt32ElementCount(int op, enum SveMaskPattern pattern, ulong imm_factor);

    /// int64_t svqincw_pat[_n_s64](int64_t op, enum svpattern pattern, uint64_t imm_factor) : "SQINCW Xtied, pattern, MUL #imm_factor"
  public static unsafe long SaturatingIncrementInt32ElementCount(long op, enum SveMaskPattern pattern, ulong imm_factor);

    /// uint32_t svqincw_pat[_n_u32](uint32_t op, enum svpattern pattern, uint64_t imm_factor) : "UQINCW Wtied, pattern, MUL #imm_factor"
  public static unsafe uint SaturatingIncrementInt32ElementCount(uint op, enum SveMaskPattern pattern, ulong imm_factor);

    /// uint64_t svqincw_pat[_n_u64](uint64_t op, enum svpattern pattern, uint64_t imm_factor) : "UQINCW Xtied, pattern, MUL #imm_factor"
  public static unsafe ulong SaturatingIncrementInt32ElementCount(ulong op, enum SveMaskPattern pattern, ulong imm_factor);

    /// svint32_t svqincw[_s32](svint32_t op, uint64_t imm_factor) : "SQINCW Ztied.S, ALL, MUL #imm_factor" or "MOVPRFX Zresult, Zop; SQINCW Zresult.S, ALL, MUL #imm_factor"
  public static unsafe Vector<int> SaturatingIncrementInt32ElementCount(Vector<int> op, ulong imm_factor);

    /// svuint32_t svqincw[_u32](svuint32_t op, uint64_t imm_factor) : "UQINCW Ztied.S, ALL, MUL #imm_factor" or "MOVPRFX Zresult, Zop; UQINCW Zresult.S, ALL, MUL #imm_factor"
  public static unsafe Vector<uint> SaturatingIncrementInt32ElementCount(Vector<uint> op, ulong imm_factor);

    /// svint32_t svqincw_pat[_s32](svint32_t op, enum svpattern pattern, uint64_t imm_factor) : "SQINCW Ztied.S, pattern, MUL #imm_factor" or "MOVPRFX Zresult, Zop; SQINCW Zresult.S, pattern, MUL #imm_factor"
  public static unsafe Vector<int> SaturatingIncrementInt32ElementCount(Vector<int> op, enum SveMaskPattern pattern, ulong imm_factor);

    /// svuint32_t svqincw_pat[_u32](svuint32_t op, enum svpattern pattern, uint64_t imm_factor) : "UQINCW Ztied.S, pattern, MUL #imm_factor" or "MOVPRFX Zresult, Zop; UQINCW Zresult.S, pattern, MUL #imm_factor"
  public static unsafe Vector<uint> SaturatingIncrementInt32ElementCount(Vector<uint> op, enum SveMaskPattern pattern, ulong imm_factor);


    /// SaturatingIncrementInt64ElementCount : Saturating increment by number of doubleword elements

    /// int32_t svqincd[_n_s32](int32_t op, uint64_t imm_factor) : "SQINCD Xtied, Wtied, ALL, MUL #imm_factor"
  public static unsafe int SaturatingIncrementInt64ElementCount(int op, ulong imm_factor);

    /// int64_t svqincd[_n_s64](int64_t op, uint64_t imm_factor) : "SQINCD Xtied, ALL, MUL #imm_factor"
  public static unsafe long SaturatingIncrementInt64ElementCount(long op, ulong imm_factor);

    /// uint32_t svqincd[_n_u32](uint32_t op, uint64_t imm_factor) : "UQINCD Wtied, ALL, MUL #imm_factor"
  public static unsafe uint SaturatingIncrementInt64ElementCount(uint op, ulong imm_factor);

    /// uint64_t svqincd[_n_u64](uint64_t op, uint64_t imm_factor) : "UQINCD Xtied, ALL, MUL #imm_factor"
  public static unsafe ulong SaturatingIncrementInt64ElementCount(ulong op, ulong imm_factor);

    /// int32_t svqincd_pat[_n_s32](int32_t op, enum svpattern pattern, uint64_t imm_factor) : "SQINCD Xtied, Wtied, pattern, MUL #imm_factor"
  public static unsafe int SaturatingIncrementInt64ElementCount(int op, enum SveMaskPattern pattern, ulong imm_factor);

    /// int64_t svqincd_pat[_n_s64](int64_t op, enum svpattern pattern, uint64_t imm_factor) : "SQINCD Xtied, pattern, MUL #imm_factor"
  public static unsafe long SaturatingIncrementInt64ElementCount(long op, enum SveMaskPattern pattern, ulong imm_factor);

    /// uint32_t svqincd_pat[_n_u32](uint32_t op, enum svpattern pattern, uint64_t imm_factor) : "UQINCD Wtied, pattern, MUL #imm_factor"
  public static unsafe uint SaturatingIncrementInt64ElementCount(uint op, enum SveMaskPattern pattern, ulong imm_factor);

    /// uint64_t svqincd_pat[_n_u64](uint64_t op, enum svpattern pattern, uint64_t imm_factor) : "UQINCD Xtied, pattern, MUL #imm_factor"
  public static unsafe ulong SaturatingIncrementInt64ElementCount(ulong op, enum SveMaskPattern pattern, ulong imm_factor);

    /// svint64_t svqincd[_s64](svint64_t op, uint64_t imm_factor) : "SQINCD Ztied.D, ALL, MUL #imm_factor" or "MOVPRFX Zresult, Zop; SQINCD Zresult.D, ALL, MUL #imm_factor"
  public static unsafe Vector<long> SaturatingIncrementInt64ElementCount(Vector<long> op, ulong imm_factor);

    /// svuint64_t svqincd[_u64](svuint64_t op, uint64_t imm_factor) : "UQINCD Ztied.D, ALL, MUL #imm_factor" or "MOVPRFX Zresult, Zop; UQINCD Zresult.D, ALL, MUL #imm_factor"
  public static unsafe Vector<ulong> SaturatingIncrementInt64ElementCount(Vector<ulong> op, ulong imm_factor);

    /// svint64_t svqincd_pat[_s64](svint64_t op, enum svpattern pattern, uint64_t imm_factor) : "SQINCD Ztied.D, pattern, MUL #imm_factor" or "MOVPRFX Zresult, Zop; SQINCD Zresult.D, pattern, MUL #imm_factor"
  public static unsafe Vector<long> SaturatingIncrementInt64ElementCount(Vector<long> op, enum SveMaskPattern pattern, ulong imm_factor);

    /// svuint64_t svqincd_pat[_u64](svuint64_t op, enum svpattern pattern, uint64_t imm_factor) : "UQINCD Ztied.D, pattern, MUL #imm_factor" or "MOVPRFX Zresult, Zop; UQINCD Zresult.D, pattern, MUL #imm_factor"
  public static unsafe Vector<ulong> SaturatingIncrementInt64ElementCount(Vector<ulong> op, enum SveMaskPattern pattern, ulong imm_factor);


  /// total method signatures: 166
  /// total method names:      19
}

@a74nh
Copy link
Contributor Author

a74nh commented Oct 26, 2023 •
edited
Loading 

  /// Rejected:
  ///   public static unsafe ulong CountElementsInAFullVector(Vector<float> value); // svlen[_f32]
  ///   public static unsafe ulong CountElementsInAFullVector(Vector<double> value); // svlen[_f64]
  ///   public static unsafe ulong CountElementsInAFullVector(Vector<sbyte> value); // svlen[_s8]
  ///   public static unsafe ulong CountElementsInAFullVector(Vector<short> value); // svlen[_s16]
  ///   public static unsafe ulong CountElementsInAFullVector(Vector<int> value); // svlen[_s32]
  ///   public static unsafe ulong CountElementsInAFullVector(Vector<long> value); // svlen[_s64]
  ///   public static unsafe ulong CountElementsInAFullVector(Vector<byte> value); // svlen[_u8]
  ///   public static unsafe ulong CountElementsInAFullVector(Vector<ushort> value); // svlen[_u16]
  ///   public static unsafe ulong CountElementsInAFullVector(Vector<uint> value); // svlen[_u32]
  ///   public static unsafe ulong CountElementsInAFullVector(Vector<ulong> value); // svlen[_u64]
  ///   Total Rejected: 10

  /// Total ACLE covered across API:      220

@a74nh
Copy link
Contributor Author

a74nh commented Oct 26, 2023

This contributes to #93095

It covers instructions in FEAT_SVE related to counting.

This list was auto generated from the C ACLE for SVE, and is in three parts:

The methods list reduced down to Vector versions. All possible varaints of T are given above the method.
The complete list of all methods. The corresponding ACLE methods and SVE instructions are given above the method.
All rejected ACLE methods. These are methods we have agreed that do not need including in C#.
Where possible, existing C# naming conventions have been matched.

Many of the C functions include predicate argument(s), of type svbool_t as the first argument. These are missing from the C# method. It is expected that the Jit will create predicates where required, or combine with uses of conditionalSelect(). For more discussion see #88140 comment.

This was referenced Oct 26, 2023
Open
Open
@tannergooding
Copy link
Member

CountLeading*Bits should be Leading*Count, CountNonzeroBits should be PopCount to match the existing name in AdvSimd (these also match the cross platform names used by the scalar types, int.PopCount for example).

CountSetPredicateBits may be a confusing name given it takes a Vector<T>. GetActiveElementCount or similar may be a "better" name and fits the terminology used by the architecture manual around "active" vs "inactive" elements.

For CountTheNumber*BitElementsInAVector, could you explain what enum svpattern pattern is meant to do here and how the parameterless overload differs?

CountTheNumberOfElementsInAFullVector() should probably not be exposed and users can just use Vector<T>.Count. Coming up with a "nice" name here would be difficult, so its likely not worth making it more difficult for a user to consume.

SaturatingDecrementByNumberOf*Elements should maybe be SaturatingDecrement*ElementCount for consistency?

Doubleword should likely be Int64 to avoid confusion with the variable meaning of Doubleword across some platforms (Win32 exclusively uses dword to mean 32-bits, as does x86/x64). The same goes for Halfword (Int16), Word (Int32), and Quadword (Int128).

@tannergooding tannergooding added api-suggestion Early API idea and discussion, it is NOT ready for implementation needs-author-action An issue or pull request that requires more info or actions from the author. and removed untriaged New issue has not been triaged by the area owner labels Oct 26, 2023
@ghost
Copy link

ghost commented Oct 26, 2023

This issue has been marked needs-author-action and may be missing some important information.

@tannergooding tannergooding added this to the 9.0.0 milestone Oct 26, 2023
@a74nh
Copy link
Contributor Author

a74nh commented Oct 27, 2023

CountLeading*Bits .....

All updated as suggested.

@ghost ghost added needs-further-triage Issue has been initially triaged, but needs deeper consideration or reconsideration and removed needs-author-action An issue or pull request that requires more info or actions from the author. labels Oct 27, 2023
@tannergooding
Copy link
Member

tannergooding commented Oct 27, 2023 •
edited
Loading

Thanks! This mostly all LGTM now, I didn’t see this handled however

For CountTheNumber*BitElementsInAVector, could you explain what enum svpattern pattern is meant to do here and how the parameterless overload differs?

At first glance the parameterless version appears identical to CountTheNumberOfElementsInAFullVector.

The version that takes the pattern would then allow

  • A fixed number (VL1 to VL256)
  • The largest power of two (POW2)
  • The largest multiple of three or four (MUL3 or MUL4)
  • All available, implicitly a multiple of two (ALL).
    • Same as the parameterless version

I don’t see this enum described anywhere so it’s difficult to determine if this name/approach is sufficient

If my understanding is correct, then I’d expect we don’t need the parameterless version and a name like GetVectorCount<T>(SveVectorPattern pattern) might be better. But I don’t have a strong opinion and would like to more clearly understand the scenario

@a74nh
Copy link
Contributor Author

a74nh commented Oct 27, 2023

For CountTheNumber*BitElementsInAVector, could you explain what enum svpattern pattern is meant to do here and how the parameterless overload differs?

At first glance the parameterless version appears identical to CountTheNumberOfElementsInAFullVector.

Yes, it's identical and more for convenience.

The version that takes the pattern would then allow

  • A fixed number (VL1 to VL256)

  • The largest power of two (POW2)

  • The largest multiple of three or four (MUL3 or MUL4)

  • All available, implicitly a multiple of two (ALL).

    • Same as the parameterless version

I don’t see this enum described anywhere so it’s difficult to determine if this name/approach is sufficient

I've added the enum onto the end of the vectorT api, plus a brief description.

If my understanding is correct, then I’d expect we don’t need the parameterless version and a name like GetVectorCount<T>(SveVectorPattern pattern) might be better. But I don’t have a strong opinion and would like to more clearly understand the scenario

GetVectorCount or maybe GetVectorElementCount would work as a name.

@tannergooding tannergooding added api-ready-for-review API is ready for review, it is NOT ready for implementation and removed api-suggestion Early API idea and discussion, it is NOT ready for implementation needs-further-triage Issue has been initially triaged, but needs deeper consideration or reconsideration labels Oct 27, 2023
@tannergooding
Copy link
Member

Thanks! I think this one is in a good enough state to be "ready for review".

I've added the enum onto the end of the vectorT api, plus a brief description.

API review will probably ask for a name that's slightly more descriptive then svpattern. SvePattern or SveVectorPattern are the two that come to mind, I don't have particular preference.

GetVectorCount or maybe GetVectorElementCount would work as a name.

Same here, I imagine API review will want something a little more friendly than CountTheNumberOf*BitElementsInAVector, I don't have a preference and am open to other suggestions.

@a74nh
Copy link
Contributor Author

a74nh commented Oct 30, 2023

Updated name of the Count functions and the enum name.

@a74nh a74nh mentioned this issue Nov 13, 2023
Closed
@bartonjs
Copy link
Member

bartonjs commented Jan 23, 2024 •
edited
Loading

Video

  • There's a static bool IsSupported { get; }, but described in a different partial/issue.
  • The parameterless overloads of Count{N}BitElements were removed.
  • The mask pattern of Count{N}BitElements were marked [ConstantExpected]
  • GetActiveElementCount should be for all integral types (add sbyte, short, int, long) and also float/double
  • All parameters named op are now named value
  • All imm_factor parameters were renamed scale and marked [ConstantExpected], and changed from ulong to byte.
  • SaturatingDecrementByteElementCount got renamed to SaturatingDecrementBy8BitElementCount (insert "By", rename "Byte" to "8Bit"), and similarly for bigger types.
  • SaturatingDecrementBy8BitElementCount (and friends), we removed the 2 argument overloads, swapped the 2nd and 3rd parameter, and defaulted the SveMaskPattern parameter
  • In SveMaskPattern:
    • SV_ALL => All
    • SV_MUL{N} => LargestMultipleOf{N}
    • SV_VL{N} => VectorCount{N}
    • SV_POW2 => LargestPowerOf2
  • SveMaskPattern was moved from being nested in Sve to being directly in Intrinsics.Arm
namespace System.Runtime.Intrinsics.Arm;

/// VectorT Summary
public abstract partial class Sve : AdvSimd /// Feature: FEAT_SVE  Category: counting
{
  public static unsafe ulong Count16BitElements([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All); // CNTH
  public static unsafe ulong Count32BitElements([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All); // CNTW
  public static unsafe ulong Count64BitElements([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All); // CNTD
  public static unsafe ulong Count8BitElements([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All); // CNTB

  /// T: byte, ushort, uint, ulong, sbyte, short, int, long, float, double
  public static unsafe ulong GetActiveElementCount(Vector<T> mask, Vector<T> from); // CNTP

  /// T: [byte, sbyte], [ushort, short], [uint, int], [ulong, long]
  public static unsafe Vector<T> LeadingSignCount(Vector<T2> value); // CLS // predicated, MOVPRFX

  /// T: [byte, sbyte], [ushort, short], [uint, int], [ulong, long]
  public static unsafe Vector<T> LeadingZeroCount(Vector<T2> value); // CLZ // predicated, MOVPRFX

  /// T: byte, ushort, uint, ulong
  public static unsafe Vector<T> LeadingZeroCount(Vector<T> value); // CLZ // predicated, MOVPRFX

  /// T: [uint, float], [ulong, double], [byte, sbyte], [ushort, short], [uint, int], [ulong, long]
  public static unsafe Vector<T> PopCount(Vector<T2> value); // CNT // predicated, MOVPRFX

  /// T: byte, ushort, uint, ulong
  public static unsafe Vector<T> PopCount(Vector<T> value); // CNT // predicated, MOVPRFX

  /// T: byte, ushort, uint, ulong
  public static unsafe int SaturatingDecrementByActiveElementCount(int value, Vector<T> from); // SQDECP

  /// T: byte, ushort, uint, ulong
  public static unsafe long SaturatingDecrementByActiveElementCount(long value, Vector<T> from); // SQDECP

  /// T: byte, ushort, uint, ulong
  public static unsafe uint SaturatingDecrementByActiveElementCount(uint value, Vector<T> from); // UQDECP

  /// T: byte, ushort, uint, ulong
  public static unsafe ulong SaturatingDecrementByActiveElementCount(ulong value, Vector<T> from); // UQDECP

  /// T: short, int, long, ushort, uint, ulong
  public static unsafe Vector<T> SaturatingDecrementByActiveElementCount(Vector<T> value, Vector<T> from); // SQDECP or UQDECP // MOVPRFX

  public static unsafe int SaturatingDecrementBy8BitElementCount(int value, [ConstantExpected] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All); // SQDECB

  public static unsafe long SaturatingDecrementBy8BitElementCount(long value, [ConstantExpected] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All); // SQDECB

  public static unsafe uint SaturatingDecrementBy8BitElementCount(uint value, [ConstantExpected] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All); // UQDECB

  public static unsafe ulong SaturatingDecrementBy8BitElementCount(ulong value, [ConstantExpected] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All); // UQDECB

  public static unsafe int SaturatingDecrementBy16BitElementCount(int value, [ConstantExpected] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All); // SQDECH

  public static unsafe long SaturatingDecrementBy16BitElementCount(long value, [ConstantExpected] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All); // SQDECH

  public static unsafe uint SaturatingDecrementBy16BitElementCount(uint value, [ConstantExpected] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All); // UQDECH

  public static unsafe ulong SaturatingDecrementBy16BitElementCount(ulong value, [ConstantExpected] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All); // UQDECH

  /// T: short, ushort
  public static unsafe Vector<T> SaturatingDecrementBy16BitElementCount(Vector<T> value, [ConstantExpected] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All); // SQDECH or UQDECH // MOVPRFX

  public static unsafe int SaturatingDecrementBy32BitElementCount(int value, [ConstantExpected] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All); // SQDECW

  public static unsafe long SaturatingDecrementBy32BitElementCount(long value, [ConstantExpected] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All); // SQDECW

  public static unsafe uint SaturatingDecrementBy32BitElementCount(uint value, [ConstantExpected] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All); // UQDECW

  public static unsafe ulong SaturatingDecrementBy32BitElementCount(ulong value, [ConstantExpected] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All); // UQDECW

  /// T: int, uint
  public static unsafe Vector<T> SaturatingDecrementBy32BitElementCount(Vector<T> value, [ConstantExpected] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All); // SQDECW or UQDECW // MOVPRFX

  public static unsafe int SaturatingDecrementBy64BitElementCount(int value, [ConstantExpected] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All); // SQDECD

  public static unsafe long SaturatingDecrementBy64BitElementCount(long value, [ConstantExpected] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All); // SQDECD

  public static unsafe uint SaturatingDecrementBy64BitElementCount(uint value, [ConstantExpected] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All); // UQDECD

  public static unsafe ulong SaturatingDecrementBy64BitElementCount(ulong value, [ConstantExpected] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All); // UQDECD

  /// T: long, ulong
  public static unsafe Vector<T> SaturatingDecrementBy64BitElementCount(Vector<T> value, [ConstantExpected] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All); // SQDECD or UQDECD // MOVPRFX

  /// T: byte, ushort, uint, ulong
  public static unsafe int SaturatingIncrementByActiveElementCount(int value, Vector<T> from); // SQINCP

  /// T: byte, ushort, uint, ulong
  public static unsafe long SaturatingIncrementByActiveElementCount(long value, Vector<T> from); // SQINCP

  /// T: byte, ushort, uint, ulong
  public static unsafe uint SaturatingIncrementByActiveElementCount(uint value, Vector<T> from); // UQINCP

  /// T: byte, ushort, uint, ulong
  public static unsafe ulong SaturatingIncrementByActiveElementCount(ulong value, Vector<T> from); // UQINCP

  /// T: short, int, long, ushort, uint, ulong
  public static unsafe Vector<T> SaturatingIncrementByActiveElementCount(Vector<T> value, Vector<T> from); // SQINCP or UQINCP // MOVPRFX

  public static unsafe int SaturatingIncrementBy8BitElementCount(int value, [ConstantExpected] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All); // SQINCB

  public static unsafe long SaturatingIncrementBy8BitElementCount(long value, [ConstantExpected] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All); // SQINCB

  public static unsafe uint SaturatingIncrementBy8BitElementCount(uint value, [ConstantExpected] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All); // UQINCB

  public static unsafe ulong SaturatingIncrementBy8BitElementCount(ulong value, [ConstantExpected] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All); // UQINCB

  public static unsafe int SaturatingIncrementBy16BitElementCount(int value, [ConstantExpected] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All); // SQINCH

  public static unsafe long SaturatingIncrementBy16BitElementCount(long value, [ConstantExpected] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All); // SQINCH

  public static unsafe uint SaturatingIncrementBy16BitElementCount(uint value, [ConstantExpected] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All); // UQINCH

  public static unsafe ulong SaturatingIncrementBy16BitElementCount(ulong value, [ConstantExpected] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All); // UQINCH

  /// T: short, ushort
  public static unsafe Vector<T> SaturatingIncrementBy16BitElementCount(Vector<T> value, [ConstantExpected] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All); // SQINCH or UQINCH // MOVPRFX

  public static unsafe int SaturatingIncrementBy32BitElementCount(int value, [ConstantExpected] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All); // SQINCW

  public static unsafe long SaturatingIncrementBy32BitElementCount(long value, [ConstantExpected] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All); // SQINCW

  public static unsafe uint SaturatingIncrementBy32BitElementCount(uint value, [ConstantExpected] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All); // UQINCW

  public static unsafe ulong SaturatingIncrementBy32BitElementCount(ulong value, [ConstantExpected] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All); // UQINCW

  /// T: int, uint
  public static unsafe Vector<T> SaturatingIncrementBy32BitElementCount(Vector<T> value, [ConstantExpected] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All); // SQINCW or UQINCW // MOVPRFX

  public static unsafe int SaturatingIncrementBy64BitElementCount(int value, [ConstantExpected] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All); // SQINCD

  public static unsafe long SaturatingIncrementBy64BitElementCount(long value, [ConstantExpected] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All); // SQINCD

  public static unsafe uint SaturatingIncrementBy64BitElementCount(uint value, [ConstantExpected] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All); // UQINCD

  public static unsafe ulong SaturatingIncrementBy64BitElementCount(ulong value, [ConstantExpected] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All); // UQINCD

  /// T: long, ulong
  public static unsafe Vector<T> SaturatingIncrementBy64BitElementCount(Vector<T> value, [ConstantExpected] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All); // SQINCD or UQINCD // MOVPRFX
}

  // All patterns used by PTRUE.
  public enum SveMaskPattern : byte
  {
    LargestPowerOf2 = 0,   // The largest power of 2.
    VectorCount1 = 1,    // 1 element.
    VectorCount2 = 2,    // 2 elements.
    VectorCount3 = 3,    // 3 elements.
    VectorCount4 = 4,    // 4 elements.
    VectorCount5 = 5,    // 5 elements.
    VectorCount6 = 6,    // 6 elements.
    VectorCount7 = 7,    // 7 elements.
    VectorCount8 = 8,    // 8 elements.
    VectorCount16 = 9,   // 16 elements.
    VectorCount32 = 10,  // 32 elements.
    VectorCount64 = 11,  // 64 elements.
    VectorCount128 = 12, // 128 elements.
    VectorCount256 = 13, // 256 elements.
    LargestMultipleOf4 = 29,  // The largest multiple of 4.
    LargestMultipleOf3 = 30,  // The largest multiple of 3.
    All  = 31    // All available (implicitly a multiple of two).
  };

@bartonjs bartonjs added api-approved API was approved in API review, it can be implemented and removed api-ready-for-review API is ready for review, it is NOT ready for implementation labels Jan 23, 2024
@billknye
Copy link

The original enum names didn't match the comment descriptions:

    SV_MUL4 = 29,  // The largest multiple of 3.
    SV_MUL3 = 30,  // The largest multiple of 4.

The approved API shape matches the comments, not the enum names which I believe is incorrect according to https://arm-software.github.io/acle/main/acle.html#sve-enum-declarations

I believe this should be reordered to

    LargestMultipleOf4 = 29,  // The largest multiple of 4.
    LargestMultipleOf3 = 30,  // The largest multiple of 3.

@a74nh
Copy link
Contributor Author

a74nh commented Jan 24, 2024

I believe this should be reordered to

    LargestMultipleOf4 = 29,  // The largest multiple of 4.
    LargestMultipleOf3 = 30,  // The largest multiple of 3.

Agreed. It wasn't quite right in the original design, then the review fixed it in the wrong direction.

Also, other inconsistencies post the review (@bartonjs, @tannergooding)

  • Count{N}BitElements - The enum should have a default argument of all
  • SaturatingDecrementBy64BitElementCount - The versions without the enum should have been removed
  • (minor nit) function name renaming means the list is no longer alphabetically ordered

@tannergooding
Copy link
Member

These should generally be fine.

The enum ordering is just a minor mistake and we obviously need to match what the hardware actually requires the ordering to be.

We discussed Count{N}BitElements being defaulted and review had stated that we didn't see a strong need given that CountNBitElements() is the same as Vector<T>.Count. We aren't blocked on adding the default parameter and were open to it if we felt there was a need for it.

SaturatingDecrementBy64BitElementCount this looks like a simple user error. We had agreed they should be removed in API review and with the last parameter defaulted, its the same signature so unnecessary.

Will fix them and adjust the ordering to be alphabetical

@tannergooding
Copy link
Member

Will fix them and adjust the ordering to be alphabetical

I actually didn't see what wasn't alphabetical, unless you were referring to strict ASCII ordering? They look to be generally A-Z, just with ByActive coming before By8Bit and with By8Bit coming before By16Bit.

@a74nh
Copy link
Contributor Author

a74nh commented Jan 24, 2024

unless you were referring to strict ASCII ordering

Yes, as it was scripts that generated the lists originally.

@ghost
Copy link

ghost commented Feb 8, 2024

Tagging subscribers to this area: @dotnet/area-system-runtime-intrinsics
See info in area-owners.md if you want to be subscribed.

Issue Details 
namespace System.Runtime.Intrinsics.Arm

/// VectorT Summary
public abstract class Sve : AdvSimd /// Feature: FEAT_SVE  Category: counting
{

  public static unsafe ulong Count16BitElements(); // CNTH

  public static unsafe ulong Count16BitElements(enum SveMaskPattern pattern); // CNTH

  public static unsafe ulong Count32BitElements(); // CNTW

  public static unsafe ulong Count32BitElements(enum SveMaskPattern pattern); // CNTW

  public static unsafe ulong Count64BitElements(); // CNTD

  public static unsafe ulong Count64BitElements(enum SveMaskPattern pattern); // CNTD

  public static unsafe ulong Count8BitElements(); // CNTB

  public static unsafe ulong Count8BitElements(enum SveMaskPattern pattern); // CNTB

  /// T: byte, ushort, uint, ulong
  public static unsafe ulong GetActiveElementCount(Vector<T> mask, Vector<T> from); // CNTP

  /// T: [byte, sbyte], [ushort, short], [uint, int], [ulong, long]
  public static unsafe Vector<T> LeadingSignCount(Vector<T2> value); // CLS // predicated, MOVPRFX

  /// T: [byte, sbyte], [ushort, short], [uint, int], [ulong, long]
  public static unsafe Vector<T> LeadingZeroCount(Vector<T2> value); // CLZ // predicated, MOVPRFX

  /// T: byte, ushort, uint, ulong
  public static unsafe Vector<T> LeadingZeroCount(Vector<T> value); // CLZ // predicated, MOVPRFX

  /// T: [uint, float], [ulong, double], [byte, sbyte], [ushort, short], [uint, int], [ulong, long]
  public static unsafe Vector<T> PopCount(Vector<T2> value); // CNT // predicated, MOVPRFX

  /// T: byte, ushort, uint, ulong
  public static unsafe Vector<T> PopCount(Vector<T> value); // CNT // predicated, MOVPRFX

  /// T: byte, ushort, uint, ulong
  public static unsafe int SaturatingDecrementByActiveElementCount(int op, Vector<T> from); // SQDECP

  /// T: byte, ushort, uint, ulong
  public static unsafe long SaturatingDecrementByActiveElementCount(long op, Vector<T> from); // SQDECP

  /// T: byte, ushort, uint, ulong
  public static unsafe uint SaturatingDecrementByActiveElementCount(uint op, Vector<T> from); // UQDECP

  /// T: byte, ushort, uint, ulong
  public static unsafe ulong SaturatingDecrementByActiveElementCount(ulong op, Vector<T> from); // UQDECP

  /// T: short, int, long, ushort, uint, ulong
  public static unsafe Vector<T> SaturatingDecrementByActiveElementCount(Vector<T> op, Vector<T> from); // SQDECP or UQDECP // MOVPRFX

  public static unsafe int SaturatingDecrementByteElementCount(int op, ulong imm_factor); // SQDECB

  public static unsafe long SaturatingDecrementByteElementCount(long op, ulong imm_factor); // SQDECB

  public static unsafe uint SaturatingDecrementByteElementCount(uint op, ulong imm_factor); // UQDECB

  public static unsafe ulong SaturatingDecrementByteElementCount(ulong op, ulong imm_factor); // UQDECB

  public static unsafe int SaturatingDecrementByteElementCount(int op, enum SveMaskPattern pattern, ulong imm_factor); // SQDECB

  public static unsafe long SaturatingDecrementByteElementCount(long op, enum SveMaskPattern pattern, ulong imm_factor); // SQDECB

  public static unsafe uint SaturatingDecrementByteElementCount(uint op, enum SveMaskPattern pattern, ulong imm_factor); // UQDECB

  public static unsafe ulong SaturatingDecrementByteElementCount(ulong op, enum SveMaskPattern pattern, ulong imm_factor); // UQDECB

  public static unsafe int SaturatingDecrementInt16ElementCount(int op, ulong imm_factor); // SQDECH

  public static unsafe long SaturatingDecrementInt16ElementCount(long op, ulong imm_factor); // SQDECH

  public static unsafe uint SaturatingDecrementInt16ElementCount(uint op, ulong imm_factor); // UQDECH

  public static unsafe ulong SaturatingDecrementInt16ElementCount(ulong op, ulong imm_factor); // UQDECH

  public static unsafe int SaturatingDecrementInt16ElementCount(int op, enum SveMaskPattern pattern, ulong imm_factor); // SQDECH

  public static unsafe long SaturatingDecrementInt16ElementCount(long op, enum SveMaskPattern pattern, ulong imm_factor); // SQDECH

  public static unsafe uint SaturatingDecrementInt16ElementCount(uint op, enum SveMaskPattern pattern, ulong imm_factor); // UQDECH

  public static unsafe ulong SaturatingDecrementInt16ElementCount(ulong op, enum SveMaskPattern pattern, ulong imm_factor); // UQDECH

  /// T: short, ushort
  public static unsafe Vector<T> SaturatingDecrementInt16ElementCount(Vector<T> op, ulong imm_factor); // SQDECH or UQDECH // MOVPRFX

  /// T: short, ushort
  public static unsafe Vector<T> SaturatingDecrementInt16ElementCount(Vector<T> op, enum SveMaskPattern pattern, ulong imm_factor); // SQDECH or UQDECH // MOVPRFX

  public static unsafe int SaturatingDecrementInt32ElementCount(int op, ulong imm_factor); // SQDECW

  public static unsafe long SaturatingDecrementInt32ElementCount(long op, ulong imm_factor); // SQDECW

  public static unsafe uint SaturatingDecrementInt32ElementCount(uint op, ulong imm_factor); // UQDECW

  public static unsafe ulong SaturatingDecrementInt32ElementCount(ulong op, ulong imm_factor); // UQDECW

  public static unsafe int SaturatingDecrementInt32ElementCount(int op, enum SveMaskPattern pattern, ulong imm_factor); // SQDECW

  public static unsafe long SaturatingDecrementInt32ElementCount(long op, enum SveMaskPattern pattern, ulong imm_factor); // SQDECW

  public static unsafe uint SaturatingDecrementInt32ElementCount(uint op, enum SveMaskPattern pattern, ulong imm_factor); // UQDECW

  public static unsafe ulong SaturatingDecrementInt32ElementCount(ulong op, enum SveMaskPattern pattern, ulong imm_factor); // UQDECW

  /// T: int, uint
  public static unsafe Vector<T> SaturatingDecrementInt32ElementCount(Vector<T> op, ulong imm_factor); // SQDECW or UQDECW // MOVPRFX

  /// T: int, uint
  public static unsafe Vector<T> SaturatingDecrementInt32ElementCount(Vector<T> op, enum SveMaskPattern pattern, ulong imm_factor); // SQDECW or UQDECW // MOVPRFX

  public static unsafe int SaturatingDecrementInt64ElementCount(int op, ulong imm_factor); // SQDECD

  public static unsafe long SaturatingDecrementInt64ElementCount(long op, ulong imm_factor); // SQDECD

  public static unsafe uint SaturatingDecrementInt64ElementCount(uint op, ulong imm_factor); // UQDECD

  public static unsafe ulong SaturatingDecrementInt64ElementCount(ulong op, ulong imm_factor); // UQDECD

  public static unsafe int SaturatingDecrementInt64ElementCount(int op, enum SveMaskPattern pattern, ulong imm_factor); // SQDECD

  public static unsafe long SaturatingDecrementInt64ElementCount(long op, enum SveMaskPattern pattern, ulong imm_factor); // SQDECD

  public static unsafe uint SaturatingDecrementInt64ElementCount(uint op, enum SveMaskPattern pattern, ulong imm_factor); // UQDECD

  public static unsafe ulong SaturatingDecrementInt64ElementCount(ulong op, enum SveMaskPattern pattern, ulong imm_factor); // UQDECD

  /// T: long, ulong
  public static unsafe Vector<T> SaturatingDecrementInt64ElementCount(Vector<T> op, ulong imm_factor); // SQDECD or UQDECD // MOVPRFX

  /// T: long, ulong
  public static unsafe Vector<T> SaturatingDecrementInt64ElementCount(Vector<T> op, enum SveMaskPattern pattern, ulong imm_factor); // SQDECD or UQDECD // MOVPRFX

  /// T: byte, ushort, uint, ulong
  public static unsafe int SaturatingIncrementByActiveElementCount(int op, Vector<T> from); // SQINCP

  /// T: byte, ushort, uint, ulong
  public static unsafe long SaturatingIncrementByActiveElementCount(long op, Vector<T> from); // SQINCP

  /// T: byte, ushort, uint, ulong
  public static unsafe uint SaturatingIncrementByActiveElementCount(uint op, Vector<T> from); // UQINCP

  /// T: byte, ushort, uint, ulong
  public static unsafe ulong SaturatingIncrementByActiveElementCount(ulong op, Vector<T> from); // UQINCP

  /// T: short, int, long, ushort, uint, ulong
  public static unsafe Vector<T> SaturatingIncrementByActiveElementCount(Vector<T> op, Vector<T> from); // SQINCP or UQINCP // MOVPRFX

  public static unsafe int SaturatingIncrementByteElementCount(int op, ulong imm_factor); // SQINCB

  public static unsafe long SaturatingIncrementByteElementCount(long op, ulong imm_factor); // SQINCB

  public static unsafe uint SaturatingIncrementByteElementCount(uint op, ulong imm_factor); // UQINCB

  public static unsafe ulong SaturatingIncrementByteElementCount(ulong op, ulong imm_factor); // UQINCB

  public static unsafe int SaturatingIncrementByteElementCount(int op, enum SveMaskPattern pattern, ulong imm_factor); // SQINCB

  public static unsafe long SaturatingIncrementByteElementCount(long op, enum SveMaskPattern pattern, ulong imm_factor); // SQINCB

  public static unsafe uint SaturatingIncrementByteElementCount(uint op, enum SveMaskPattern pattern, ulong imm_factor); // UQINCB

  public static unsafe ulong SaturatingIncrementByteElementCount(ulong op, enum SveMaskPattern pattern, ulong imm_factor); // UQINCB

  public static unsafe int SaturatingIncrementInt16ElementCount(int op, ulong imm_factor); // SQINCH

  public static unsafe long SaturatingIncrementInt16ElementCount(long op, ulong imm_factor); // SQINCH

  public static unsafe uint SaturatingIncrementInt16ElementCount(uint op, ulong imm_factor); // UQINCH

  public static unsafe ulong SaturatingIncrementInt16ElementCount(ulong op, ulong imm_factor); // UQINCH

  public static unsafe int SaturatingIncrementInt16ElementCount(int op, enum SveMaskPattern pattern, ulong imm_factor); // SQINCH

  public static unsafe long SaturatingIncrementInt16ElementCount(long op, enum SveMaskPattern pattern, ulong imm_factor); // SQINCH

  public static unsafe uint SaturatingIncrementInt16ElementCount(uint op, enum SveMaskPattern pattern, ulong imm_factor); // UQINCH

  public static unsafe ulong SaturatingIncrementInt16ElementCount(ulong op, enum SveMaskPattern pattern, ulong imm_factor); // UQINCH

  /// T: short, ushort
  public static unsafe Vector<T> SaturatingIncrementInt16ElementCount(Vector<T> op, ulong imm_factor); // SQINCH or UQINCH // MOVPRFX

  /// T: short, ushort
  public static unsafe Vector<T> SaturatingIncrementInt16ElementCount(Vector<T> op, enum SveMaskPattern pattern, ulong imm_factor); // SQINCH or UQINCH // MOVPRFX

  public static unsafe int SaturatingIncrementInt32ElementCount(int op, ulong imm_factor); // SQINCW

  public static unsafe long SaturatingIncrementInt32ElementCount(long op, ulong imm_factor); // SQINCW

  public static unsafe uint SaturatingIncrementInt32ElementCount(uint op, ulong imm_factor); // UQINCW

  public static unsafe ulong SaturatingIncrementInt32ElementCount(ulong op, ulong imm_factor); // UQINCW

  public static unsafe int SaturatingIncrementInt32ElementCount(int op, enum SveMaskPattern pattern, ulong imm_factor); // SQINCW

  public static unsafe long SaturatingIncrementInt32ElementCount(long op, enum SveMaskPattern pattern, ulong imm_factor); // SQINCW

  public static unsafe uint SaturatingIncrementInt32ElementCount(uint op, enum SveMaskPattern pattern, ulong imm_factor); // UQINCW

  public static unsafe ulong SaturatingIncrementInt32ElementCount(ulong op, enum SveMaskPattern pattern, ulong imm_factor); // UQINCW

  /// T: int, uint
  public static unsafe Vector<T> SaturatingIncrementInt32ElementCount(Vector<T> op, ulong imm_factor); // SQINCW or UQINCW // MOVPRFX

  /// T: int, uint
  public static unsafe Vector<T> SaturatingIncrementInt32ElementCount(Vector<T> op, enum SveMaskPattern pattern, ulong imm_factor); // SQINCW or UQINCW // MOVPRFX

  public static unsafe int SaturatingIncrementInt64ElementCount(int op, ulong imm_factor); // SQINCD

  public static unsafe long SaturatingIncrementInt64ElementCount(long op, ulong imm_factor); // SQINCD

  public static unsafe uint SaturatingIncrementInt64ElementCount(uint op, ulong imm_factor); // UQINCD

  public static unsafe ulong SaturatingIncrementInt64ElementCount(ulong op, ulong imm_factor); // UQINCD

  public static unsafe int SaturatingIncrementInt64ElementCount(int op, enum SveMaskPattern pattern, ulong imm_factor); // SQINCD

  public static unsafe long SaturatingIncrementInt64ElementCount(long op, enum SveMaskPattern pattern, ulong imm_factor); // SQINCD

  public static unsafe uint SaturatingIncrementInt64ElementCount(uint op, enum SveMaskPattern pattern, ulong imm_factor); // UQINCD

  public static unsafe ulong SaturatingIncrementInt64ElementCount(ulong op, enum SveMaskPattern pattern, ulong imm_factor); // UQINCD

  /// T: long, ulong
  public static unsafe Vector<T> SaturatingIncrementInt64ElementCount(Vector<T> op, ulong imm_factor); // SQINCD or UQINCD // MOVPRFX

  /// T: long, ulong
  public static unsafe Vector<T> SaturatingIncrementInt64ElementCount(Vector<T> op, enum SveMaskPattern pattern, ulong imm_factor); // SQINCD or UQINCD // MOVPRFX


  // All patterns used by PTRUE.
  enum SveMaskPattern
  {
    SV_POW2 = 0,   // The largest power of 2.
    SV_VL1 = 1,    // 1 element.
    SV_VL2 = 2,    // 2 elements.
    SV_VL3 = 3,    // 3 elements.
    SV_VL4 = 4,    // 4 elements.
    SV_VL5 = 5,    // 5 elements.
    SV_VL6 = 6,    // 6 elements.
    SV_VL7 = 7,    // 7 elements.
    SV_VL8 = 8,    // 8 elements.
    SV_VL16 = 9,   // 16 elements.
    SV_VL32 = 10,  // 32 elements.
    SV_VL64 = 11,  // 64 elements.
    SV_VL128 = 12, // 128 elements.
    SV_VL256 = 13, // 256 elements.
    SV_MUL4 = 29,  // The largest multiple of 3.
    SV_MUL3 = 30,  // The largest multiple of 4.
    SV_ALL = 31    // All available (implicitly a multiple of two).
  };

  /// total method signatures: 100

}

Details

CountNBitElements(enum SveMaskPattern pattern)
Set scalar to multiple of predicate constraint element count
Determines the number of active elements implied by pattern, multiplies that by an immediate in the range 1 to 16 inclusive, and then places the result in the scalar destination.

Pattern limits the number of active elements in a single predicate to:

  • A fixed number (VL1 to VL256)
  • The largest power of two (POW2)
  • The largest multiple of three or four (MUL3 or MUL4)
  • All available, implicitly a multiple of two (ALL).

CountNBitElements()
Identical to: CountNBitElements(SV_ALL)

Author: a74nh
Assignees: -
Labels:

api-approved, area-System.Runtime.Intrinsics
Milestone: 9.0.0

@kunalspathak kunalspathak mentioned this issue Mar 19, 2024
Open
@jeffhandley jeffhandley added the arm-sve Work related to arm64 SVE/SVE2 support label Jul 28, 2024
@jeffhandley jeffhandley modified the milestones: 9.0.0, 10.0.0 Jul 28, 2024
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Assignees
No one assigned
Labels
api-approved API was approved in API review, it can be implemented area-System.Runtime.Intrinsics arm-sve Work related to arm64 SVE/SVE2 support
Projects
None yet
Milestone
10.0.0
Development

No branches or pull requests
5 participants
@billknye @jeffhandley @a74nh @tannergooding @bartonjs