imprimer un __m128i variable

• Portable à travers gcc/clang/CPI/MSVC, le C et le C++.
• totalement en sécurité avec tous les niveaux d'optimisation: pas de pointeur aliasing (contrairement à la plupart des autres réponses)
• impression en hexadécimal comme u8 u16, u32, ou u64 éléments (@AG1 réponse)
• Imprime dans la mémoire de commande (moins-élément important de la première, comme _mm_setr_epiX). Inverser les indices de tableau, si vous préférez impression dans le même ordre d'Intel manuels d'utilisation, où l'élément le plus significatif est sur la gauche (comme _mm_set_epiX). Connexes: Convention pour l'affichage des registres vectoriels

À l'aide d'un __m128i* à charger à partir d'un tableau de int est sûr parce que la __m128 types sont définis pour permettre le repliement. (par exemple, dans le ccag-têtes, la définition inclut les __attribute__((may_alias)).)

L'inverse n'est pas coffre-fort (une __m128i objet et un int pointeur). Il peut arriver de travailler dans la plupart des cas, mais pourquoi prendre le risque?

(uint32_t*) &my_vector viole le C et le C++ aliasing règles, et n'est pas garanti pour fonctionner de la façon que vous attendez. Le stockage à un tableau et ensuite l'accès, il est garanti d'être en sécurité. Même optimise loin avec la plupart des compilateurs, de sorte que vous obtenez movq /pextrq directement à partir de xmm entier registres au lieu d'une réelle magasin/recharger, par exemple.

Source + asm sortie sur le Godbolt compilateur explorer: la preuve il compile avec MSVC et ainsi de suite.

#include <immintrin.h>
#include <stdint.h>
#include <stdio.h>

#ifndef __cplusplus
#include <stdalign.h>   //C11 defines _Alignas().  This header defines alignas()
#endif

void p128_hex_u8(__m128i in) {
    alignas(16) uint8_t v[16];
    _mm_store_si128((__m128i*)v, in);
    printf("v16_u8: %x %x %x %x | %x %x %x %x | %x %x %x %x | %x %x %x %x\n",
           v[0], v[1],  v[2],  v[3],  v[4],  v[5],  v[6],  v[7],
           v[8], v[9], v[10], v[11], v[12], v[13], v[14], v[15]);
}

void p128_hex_u16(__m128i in) {
    alignas(16) uint16_t v[8];
    _mm_store_si128((__m128i*)v, in);
    printf("v8_u16: %x %x %x %x,  %x %x %x %x\n", v[0], v[1], v[2], v[3], v[4], v[5], v[6], v[7]);
}

void p128_hex_u32(__m128i in) {
    alignas(16) uint32_t v[4];
    _mm_store_si128((__m128i*)v, in);
    printf("v4_u32: %x %x %x %x\n", v[0], v[1], v[2], v[3]);
}

void p128_hex_u64(__m128i in) {
    alignas(16) unsigned long long v[2];  //uint64_t might give format-string warnings with %llx; it's just long in some ABIs
    _mm_store_si128((__m128i*)v, in);
    printf("v2_u64: %llx %llx\n", v[0], v[1]);
}

Si vous avez besoin de portabilité de C99 ou C++03 ou plus tôt (c'est à dire sans C11 /C++11), retirez la alignas() et l'utilisation storeu au lieu de store. Ou utiliser __attribute__((aligned(16))) ou __declspec( align(16) ) à la place.

(Si vous écrivez du code avec intrinsèques, vous devriez être en utilisant une récente version de compilateur. Nouveaux compilateurs font généralement mieux asm que les anciens compilateurs, y compris pour les SSE/AVX intrinsèques. Mais peut-être que vous voulez utiliser gcc-6.3 avec -std=gnu++03 C++03 mode pour une base de code qui n'est pas prêt pour le C++11 ou quelque chose.)

---

Exemple de sortie de l'appel de tous les 4 fonctions sur

//source used:
__m128i vec = _mm_setr_epi8(1, 2, 3, 4, 5, 6, 7,
                            8, 9, 10, 11, 12, 13, 14, 15, 16);

//output:

v2_u64: 0x807060504030201 0x100f0e0d0c0b0a09
v4_u32: 0x4030201 0x8070605 0xc0b0a09 0x100f0e0d
v8_u16: 0x201 0x403 0x605 0x807  | 0xa09 0xc0b 0xe0d 0x100f
v16_u8: 0x1 0x2 0x3 0x4 | 0x5 0x6 0x7 0x8 | 0x9 0xa 0xb 0xc | 0xd 0xe 0xf 0x10

Ajuster le format des chaînes si vous voulez pad avec les zéros non significatifs pour la cohérence des résultats de la largeur. Voir printf(3).

OriginalL'auteur

#include<stdio.h>
#include<emmintrin.h>
int main()
{
    __m128i a = _mm_set_epi32(1,2,3,4);
    __m128i b = _mm_set_epi32(1,2,3,4);
    __m128i c;

    const int32_t* q; 
    //add a pointer 
    c = _mm_add_epi32(a,b);

    q = (const int32_t*) &c;
    printf("%d\n",q[2]);
    //printf("%d\n",c[2]);
    return 0;
}

Essayer ce code.

OriginalL'auteur