Forum Programmation.c++ intel intrinsics

Posté par . Licence CC by-sa
3
22
nov.
2014

Bonjour,

Je manipule des vecteurs 16 bits avec les intrinsics SSE et GCC, tout fonctionne bien.
Il y a cependant une manipulation que je n'arrive pas à concrétiser : ces vecteurs 16 bits sont destinés à être affichés à l'écran en tant qu'image. Il me faut donc les convertir en vecteurs 8 bits après désaturation (je désature bien mais mon type de sortie __m128i contient toujours des integers 16 bits).

Quelqu'un connaîtrait-il la bonne méthode, tout en restant dans les registres SSE ? (pour l'instant, je fais une conversion avec une boucle accélérée openmp).

Merci

Bon, il semble que sse3 me permet

__m128i _mm_shuffle_epi8 ( __m128i a, __m128i b)

me reste plus qu'à trouver le bon masque ou la macro qui va bien.

  • # Une union ?

    Posté par . Évalué à 2.

    typedef union
    {
    __m128i trucmuche;
    std::array<unsigned char, sizeof(__m128i) / sizeof(unsigned char)> chose
    };
    • [^] # Re: Une union ?

      Posté par . Évalué à 1. Dernière modification le 22/11/14 à 19:41.

      Ca n'est pas tout à fait mon cas :

      je me retrouve avec 2 registres __m128i contenant

      __m128i{0x00, A, 0x00, B, 0x00, C .....}

      et

      __m128i{0x00, I, 0x00, J, 0x00, K .....}

      qui doivent devenir

      __m128i{A, B, C, ..... I, J, K,...}

      mais merci pour l'idée

  • # une solution

    Posté par . Évalué à 2. Dernière modification le 22/11/14 à 20:09.

    Bien, je pense pouvoir faire affaire avec :

    // macro pompée sur projet Simd (http://sourceforge.net/projects/simd/)
    #define SIMD_CHAR_AS_LONGLONG(a) (((long long)a) & 0xFF)
    #define SIMD_LL_SETR_EPI8(a, b, c, d, e, f, g, h) \
        SIMD_CHAR_AS_LONGLONG(a) | (SIMD_CHAR_AS_LONGLONG(b) << 8) | \
        (SIMD_CHAR_AS_LONGLONG(c) << 16) | (SIMD_CHAR_AS_LONGLONG(d) << 24) | \
        (SIMD_CHAR_AS_LONGLONG(e) << 32) | (SIMD_CHAR_AS_LONGLONG(f) << 40) | \
        (SIMD_CHAR_AS_LONGLONG(g) << 48) | (SIMD_CHAR_AS_LONGLONG(h) << 56)
    #define SIMD_MM_SETR_EPI8(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, aa, ab, ac, ad, ae, af) \
        {SIMD_LL_SETR_EPI8(a0, a1, a2, a3, a4, a5, a6, a7), SIMD_LL_SETR_EPI8(a8, a9, aa, ab, ac, ad, ae, af)}
    
    // nos 2 masques
    const __m128i FIRST_PACKET = SIMD_MM_SETR_EPI8(0xF,0xD,0xB,0x9,0x7,0x5,0x3,0x1,-1,-1,-1,-1,-1,-1,-1,-1);
    const __m128i SECOND_PACKET = SIMD_MM_SETR_EPI8(-1,-1,-1,-1,-1,-1,-1,-1,0xF,0xD,0xB,0x9,0x7,0x5,0x3,0x1);
    
    // les registre à entrelacer
    __m128i k1 = _mm_set_epi8(0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15);
    __m128i k2 = _mm_set_epi8(16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31);
    
    // distribution des octets
    __m128i res1 = _mm_shuffle_epi8 (k1,  FIRST_PACKET);
    __m128i res2 = _mm_shuffle_epi8 (k2,  SECOND_PACKET);
    
    // le résultat escompté
    __m128i res = res1 + res2;
    
    out: 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30
    • [^] # Re: une solution

      Posté par . Évalué à 2.

      et pour les plus assidus l'implémentation

      #define SIMD_CHAR_AS_LONGLONG(a) (((long long)a) & 0xFF)
      #define SIMD_LL_SETR_EPI8(a, b, c, d, e, f, g, h) \
          SIMD_CHAR_AS_LONGLONG(a) | (SIMD_CHAR_AS_LONGLONG(b) << 8) | \
          (SIMD_CHAR_AS_LONGLONG(c) << 16) | (SIMD_CHAR_AS_LONGLONG(d) << 24) | \
          (SIMD_CHAR_AS_LONGLONG(e) << 32) | (SIMD_CHAR_AS_LONGLONG(f) << 40) | \
          (SIMD_CHAR_AS_LONGLONG(g) << 48) | (SIMD_CHAR_AS_LONGLONG(h) << 56)
      #define SIMD_MM_SETR_EPI8(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, aa, ab, ac, ad, ae, af) \
      {SIMD_LL_SETR_EPI8(a0, a1, a2, a3, a4, a5, a6, a7), SIMD_LL_SETR_EPI8(a8, a9, aa, ab, ac, ad, ae, af)}
      
      const __m128i FIRST_MASK = SIMD_MM_SETR_EPI8(0x0,0x2,0x4,0x6,0x8,0xA,0xC,0xE,-1,-1,-1,-1,-1,-1,-1,-1);
      const __m128i SECOND_MASK = SIMD_MM_SETR_EPI8(-1,-1,-1,-1,-1,-1,-1,-1,0x0,0x2,0x4,0x6,0x8,0xA,0xC,0xE);
      
      struct U122U8
      {
      
          void operator()(const unsigned char* src, unsigned char* dst, int pixelsCount) const
          {
      
              const quint16 *pIn = reinterpret_cast<const quint16 *>(src);
      #pragma omp parallel for schedule(static)
              for (int i=0; i< pixelsCount; i+=16) {
                  // charge 8 pixels allignés
                  // désature en shiftant à droite
                  // réarrange les octets
                  const __m128i first = _mm_shuffle_epi8 (
                              _mm_srli_epi16(
                                  _mm_load_si128((const __m128i *)(pIn + i)), 4),
                              FIRST_MASK);
      
                  // même chose pour les 8 octets suivants
                  const __m128i second = _mm_shuffle_epi8 (
                              _mm_srli_epi16(
                                  _mm_load_si128((const __m128i *)(pIn + i + 8)), 4),
                              SECOND_MASK);
      
                  // bitwise OR
                  _mm_storeu_si128((__m128i *)(dst + i), _mm_or_si128(first, second));
              }
          }
      };
    • [^] # Re: une solution

      Posté par . Évalué à 2.

      Qu'est-ce que c'est moche par rapport aux intrinsics Altivec. À chaque fois que je lis du code SSE, je regrette la desparition des PPC…

Suivre le flux des commentaires

Note : les commentaires appartiennent à ceux qui les ont postés. Nous n'en sommes pas responsables.