Come scegliere le varianti del predicato di confronto di AVX

Question

Nelle estensioni vettoriali avanzate (AVX) le istruzioni di confronto come _m256_cmp_ps, l'ultimo argomento è un predicato di confronto. Le scelte per il predicato mi sommergono. Sembrano essere un triplo di tipo, ordine, segnalazione. E.g. _CMP_LE_OS è "minore o uguale, ordinato, segnalazione.

Per i principianti, esiste un motivo di prestazioni per selezionare la segnalazione o non segnalazione, e, analogamente, è ordinato o non ordinato più velocemente dell'altro?

E cosa significa "non segnalazione"? Non riesco a trovare questo nei documenti affatto. Qualsiasi regola empirica su quando selezionare cosa?

Ecco le scelte predicato da avxintrin.h:

/* Compare */ 
#define _CMP_EQ_OQ 0x00 /* Equal (ordered, non-signaling) */ 
#define _CMP_LT_OS 0x01 /* Less-than (ordered, signaling) */ 
#define _CMP_LE_OS 0x02 /* Less-than-or-equal (ordered, signaling) */ 
#define _CMP_UNORD_Q 0x03 /* Unordered (non-signaling) */ 
#define _CMP_NEQ_UQ 0x04 /* Not-equal (unordered, non-signaling) */ 
#define _CMP_NLT_US 0x05 /* Not-less-than (unordered, signaling) */ 
#define _CMP_NLE_US 0x06 /* Not-less-than-or-equal (unordered, signaling) */ 
#define _CMP_ORD_Q 0x07 /* Ordered (nonsignaling) */ 
#define _CMP_EQ_UQ 0x08 /* Equal (unordered, non-signaling) */ 
#define _CMP_NGE_US 0x09 /* Not-greater-than-or-equal (unord, signaling) */ 
#define _CMP_NGT_US 0x0a /* Not-greater-than (unordered, signaling) */ 
#define _CMP_FALSE_OQ 0x0b /* False (ordered, non-signaling) */ 
#define _CMP_NEQ_OQ 0x0c /* Not-equal (ordered, non-signaling) */ 
#define _CMP_GE_OS 0x0d /* Greater-than-or-equal (ordered, signaling) */ 
#define _CMP_GT_OS 0x0e /* Greater-than (ordered, signaling) */ 
#define _CMP_TRUE_UQ 0x0f /* True (unordered, non-signaling) */ 
#define _CMP_EQ_OS 0x10 /* Equal (ordered, signaling) */ 
#define _CMP_LT_OQ 0x11 /* Less-than (ordered, non-signaling) */ 
#define _CMP_LE_OQ 0x12 /* Less-than-or-equal (ordered, non-signaling) */ 
#define _CMP_UNORD_S 0x13 /* Unordered (signaling) */ 
#define _CMP_NEQ_US 0x14 /* Not-equal (unordered, signaling) */ 
#define _CMP_NLT_UQ 0x15 /* Not-less-than (unordered, non-signaling) */ 
#define _CMP_NLE_UQ 0x16 /* Not-less-than-or-equal (unord, non-signaling) */ 
#define _CMP_ORD_S 0x17 /* Ordered (signaling) */ 
#define _CMP_EQ_US 0x18 /* Equal (unordered, signaling) */ 
#define _CMP_NGE_UQ 0x19 /* Not-greater-than-or-equal (unord, non-sign) */ 
#define _CMP_NGT_UQ 0x1a /* Not-greater-than (unordered, non-signaling) */ 
#define _CMP_FALSE_OS 0x1b /* False (ordered, signaling) */ 
#define _CMP_NEQ_OS 0x1c /* Not-equal (ordered, signaling) */ 
#define _CMP_GE_OQ 0x1d /* Greater-than-or-equal (ordered, non-signaling) */ 
#define _CMP_GT_OQ 0x1e /* Greater-than (ordered, non-signaling) */ 
#define _CMP_TRUE_US 0x1f /* True (unordered, signaling) */ 

Answer 1

ordinato vs non ordinata ha a che fare con se il confronto è vero se uno degli operandi contiene un NaN (vedi What does ordered/unordered comparison mean?). Segnalazione (S) vs non segnalazione (Q per quiet?) Determinerà se un'eccezione viene sollevata se un operando contiene un NaN.

Dal punto di vista delle prestazioni, queste dovrebbero essere tutte uguali (presupponendo ovviamente che non vengano sollevate eccezioni). Se vuoi essere avvisato quando c'è un NaN, allora vuoi segnalarlo. Per quanto riguarda ordinato vs non ordinato, tutto dipende da come si desidera trattare con NaNs.