Drucken Sie eine __m128i-Variable

Ich versuche zu lernen, mit Intrinsic zu codieren, und unten ist ein Code, der Additionen durchführt

compiler used: icc

#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;
        c = _mm_add_epi32(a,b);
        printf("%d\n",c[2]);
        return 0;
}

Ich bekomme den folgenden Fehler:

test.c(9): error: expression must have pointer-to-object type
        printf("%d\n",c[2]);

Wie drucke ich die Werte in der Variablen c was vom Typ ist __m128i

Verwenden Sie diese Funktion, um sie auszudrucken:

#include <stdint.h>
#include <string.h>

void print128_num(__m128i var)
{
    uint16_t val[8];
    memcpy(val, &var, sizeof(val));
    printf("Numerical: %i %i %i %i %i %i %i %i \n", 
           val[0], val[1], val[2], val[3], val[4], val[5], 
           val[6], val[7]);
}

Sie teilen 128 Bit in 16 Bit (oder 32 Bit) auf, bevor Sie sie drucken.

Dies ist eine Möglichkeit zum 64-Bit-Splitten und -Drucken, wenn Sie über 64-Bit-Unterstützung verfügen:

#include <inttypes.h>

void print128_num(__m128i var) 
{
    int64_t v64val[2];
    memcpy(v64val, &var, sizeof(v64val));
    printf("%.16llx %.16llx\n", v64val[1], v64val[0]);
}

Notiz: Gießen der &var direkt zu einem int* oder uint16_t* würde auch MSVC funktionieren, aber dies verstößt gegen striktes Aliasing und ist ein undefiniertes Verhalten. Verwenden memcpy ist der standardkonforme Weg, dasselbe zu tun, und mit minimaler Optimierung generiert der Compiler genau denselben Binärcode.

• Über gcc/clang/ICC/MSVC, C und C++ portierbar.
• völlig sicher bei allen Optimierungsstufen: keine strikte Aliasing-Verletzung UB
• print in hex als u8-, u16-, u32- oder u64-Elemente (basierend auf der Antwort von @ AG1)
• Druckt in Speicherreihenfolge (das niederwertigste Element zuerst, z _mm_setr_epiX). Kehren Sie die Array-Indizes um, wenn Sie es vorziehen, in der gleichen Reihenfolge zu drucken, die Intels Handbücher verwenden, wobei sich das wichtigste Element auf der linken Seite befindet (wie z _mm_set_epiX). Verwandte: Konvention zum Anzeigen von Vektorregistern

Verwendung einer __m128i* aus einem Array von zu laden int ist sicher, weil die __m128 Typen sind so definiert, dass sie Aliasing erlauben, genau wie ISO C unsigned char*. (z. B. in den Kopfzeilen von gcc enthält die Definition __attribute__((may_alias)).)

Die Umkehrung ist nicht sicher (zeigt auf eine int* auf einen Teil von a __m128i Objekt). MSVC garantiert, dass dies sicher ist, aber GCC/clang nicht. (-fstrict-aliasing ist standardmäßig aktiviert). Es funktioniert manchmal mit GCC/clang, aber warum es riskieren? Es stört manchmal sogar die Optimierung; siehe diese Fragen und Antworten. Siehe auch Ist `reinterpret_cast`ing zwischen Hardware-SIMD-Vektorzeiger und dem entsprechenden Typ ein undefiniertes Verhalten?

Siehe GCC AVX _m256i Umwandlung in int Array führt zu falschen Werten für ein reales Beispiel für GCC-Breaking-Code, der auf zeigt int* an einer __m256i.

(uint32_t*) &my_vector verstößt gegen die C- und C++-Aliasing-Regeln und funktioniert nicht garantiert so, wie Sie es erwarten. Das Speichern in einem lokalen Array und der anschließende Zugriff darauf ist garantiert sicher. Es optimiert sogar mit den meisten Compilern, so dass Sie es bekommen movq / pextrq direkt von xmm zu Integer-Registern statt an tatsächlich z.B. speichern/neu laden.

Source + asm-Ausgabe im Godbolt-Compiler-Explorer: Beweis, dass es mit MSVC kompiliert und so weiter.

#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]);
}

Wenn Sie Portabilität auf C99 oder C++03 oder früher (dh ohne C11 / C++11) benötigen, entfernen Sie die alignas() und verwenden storeu Anstatt von store. Oder verwenden __attribute__((aligned(16))) oder __declspec( align(16) ) stattdessen.

(Wenn Sie Code mit Intrinsic schreiben, sollten Sie eine neuere Compiler-Version verwenden. Neuere Compiler machen normalerweise besser asm als ältere Compiler, einschließlich für SSE/AVX-Intrinsic. Aber vielleicht möchten Sie gcc-6.3 mit verwenden -std=gnu++03 C++03-Modus für eine Codebasis, die nicht für C++11 oder so bereit ist.)

Beispielausgabe vom Aufrufen aller 4 Funktionen

// 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

Passen Sie die Formatzeichenfolgen an, wenn Sie für eine konsistente Ausgabebreite mit führenden Nullen auffüllen möchten. Sehen printf(3).

Ich weiß, dass diese Frage mit C gekennzeichnet ist, aber es war das beste Suchergebnis, auch wenn nach einer C++-Lösung für dasselbe Problem gesucht wurde.

Dies könnte also eine C++-Implementierung sein:

#include <string>
#include <cstring>
#include <sstream>

#if defined(__SSE2__)
template <typename T>
std::string __m128i_toString(const __m128i var) {
    std::stringstream sstr;
    T values[16/sizeof(T)];
    std::memcpy(values,&var,sizeof(values)); //See discussion below
    if (sizeof(T) == 1) {
        for (unsigned int i = 0; i < sizeof(__m128i); i++) { //C++11: Range for also possible
            sstr << (int) values[i] << " ";
        }
    } else {
        for (unsigned int i = 0; i < sizeof(__m128i) / sizeof(T); i++) { //C++11: Range for also possible
            sstr << values[i] << " ";
        }
    }
    return sstr.str();
}
#endif

Verwendungszweck:

#include <iostream>
[..]
__m128i x
[..]
std::cout << __m128i_toString<uint8_t>(x) << std::endl;
std::cout << __m128i_toString<uint16_t>(x) << std::endl;
std::cout << __m128i_toString<uint32_t>(x) << std::endl;
std::cout << __m128i_toString<uint64_t>(x) << std::endl;

Ergebnis:

141 114 0 0 0 0 0 0 151 104 0 0 0 0 0 0
29325 0 0 0 26775 0 0 0
29325 0 26775 0
29325 26775

Hinweis: Es gibt eine einfache Möglichkeit, dies zu vermeiden if (size(T)==1)siehe https://stackoverflow.com/a/28414758/2436175

#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;
}

Versuchen Sie diesen Code.