Как привести к неподписанному векторному типу после использования __builtin_msa_ld_ * - PullRequest
Новая
       55

Как привести к неподписанному векторному типу после использования __builtin_msa_ld_ *

0 голосов
/ 21 октября 2018

Я оцениваю MIPS SIMD Architecture (MSA) программирование с использованием Codescape GCC Toolchain .Там не так много информации о MSA и встроенных.(Насколько я могу судить, есть только два процессора MSA, P5600 и Warrior I6400, и они впервые стали доступны несколько лет назад).

Моя тестовая программа ниже. 

#include <msa.h>
#include <stdint.h>

#define ALIGN16 __attribute__((aligned(16)))

int main(int argc, char* argv[])
{
    ALIGN16 uint32_t a[] = {64, 128, 256, 512};
    ALIGN16 uint32_t b[] = {1024, 2048, 4096, 8192};
    ALIGN16 uint32_t c[4];

    v4u32 va = __builtin_msa_ld_w (a, 0);
    v4u32 vb = __builtin_msa_ld_w (b, 0);

    v4u32 vc = __builtin_msa_adds_u_w (va, vb);
    __builtin_msa_st_w (vc, c, 0);

    return 0;
}

Компиляция программы приводит к ошибкам, показанным ниже.Проблема в том, что векторные загрузки возвращают вектор со знаком , но мои векторы не подписаны.У меня похожая проблема с векторными хранилищами. 

// The 4 vector loads provided through builtins
v16i8 __builtin_msa_ld_b (void *, imm_n512_511);    // byte
v8i16 __builtin_msa_ld_h (void *, imm_n1024_1022);  // half word
v4i32 __builtin_msa_ld_w (void *, imm_n2048_2044);  // word
v2i64 __builtin_msa_ld_d (void *, imm_n4096_4088);  // double word

(imm_n512_511 и друзья обсуждаются в руководстве GCC по адресу 6.59.16 Поддержка MIPS SIMD Architecture (MSA) ).

Я читаю статью MIPS (?) На Архитектура MIPS SIMD , но в ней не обсуждается, как преобразовывать целочисленные векторные типы.Существует множество инструкций преобразования с плавающей точкой, но ничего для целочисленных типов.

Является ли простое приведение предпочтительным способом преобразования между целочисленными векторными типами?Или есть что-то еще, что я должен делать? 

MSA$ mips-img-linux-gnu-gcc.exe -mmsa test.c -c
test.c: In function 'main':
test.c:12:2: note: use -flax-vector-conversions to permit conversions between ve
ctors with differing element types or numbers of subparts
  v4u32 va = __builtin_msa_ld_w (a, 0);
  ^~~~~
test.c:12:13: error: incompatible types when initializing type 'v4u32 {aka __vec
tor(4) unsigned int}' using type '__vector(4) int'
  v4u32 va = __builtin_msa_ld_w (a, 0);
             ^~~~~~~~~~~~~~~~~~
test.c:13:13: error: incompatible types when initializing type 'v4u32 {aka __vec
tor(4) unsigned int}' using type '__vector(4) int'
  v4u32 vb = __builtin_msa_ld_w (b, 0);
             ^~~~~~~~~~~~~~~~~~
test.c:16:22: error: incompatible type for argument 1 of '__builtin_msa_st_w'
  __builtin_msa_st_w (vc, c, 0);
                      ^~
test.c:16:22: note: expected '__vector(4) int' but argument is of type 'v4u32 {a
ka __vector(4) unsigned int}'

Ответы [ 2 ]

0 голосов
/ 21 октября 2018

Вот альтернатива, которая работает с C и C ++.Он выполняет memcpy для переменных регистра.Встроенные функции заимствованы из поддержки ARM NEON.ARM обеспечивает приведение к векторам NEON, например vreinterpretq_u64_u8.inline для функций требует C99. 

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

inline v4i32 reinterpretq_i32_u32(const v4u32 val) {
    v4i32 res;
    memcpy(&res, &val, sizeof(res));
    return res;
}

inline v4u32 reinterpretq_u32_i32(const v4i32 val) {
    v4u32 res;
    memcpy(&res, &val, sizeof(res));
    return res;
}

#define ALIGN16 __attribute__((aligned(16)))

int main(int argc, char* argv[])
{
    ALIGN16 uint32_t a[] = {64, 128, 256, 512};
    ALIGN16 uint32_t b[] = {1024, 2048, 4096, 8192};
    ALIGN16 uint32_t c[4];

    v4u32 va = reinterpretq_u32_i32(__builtin_msa_ld_w (a, 0));
    v4u32 vb = reinterpretq_u32_i32(__builtin_msa_ld_w (b, 0));

    v4u32 vc = __builtin_msa_adds_u_w (va, vb);
    __builtin_msa_st_w (reinterpretq_i32_u32(vc), c, 0);

    return 0;
}

и компиляцию на -O3 (она чиста на -Wall -Wextra): 

MSA$ mips-img-linux-gnu-gcc.exe -O3 -mmsa test.c -c
MSA$

И разборка выглядит какон проходит тестирование на анализ: 

MSA$ mips-img-linux-gnu-objdump.exe --disassemble test.o

test.o:     file format elf32-tradbigmips

Disassembly of section .text:

00000000 <main>:
   0:   27bdffc8        addiu      sp,sp,-56
   4:   3c020000        lui        v0,0x0
   8:   24420000        addiu      v0,v0,0
   c:   78001062        ld.w       $w1,0(v0)
  10:   3c020000        lui        v0,0x0
  14:   24420000        addiu      v0,v0,0
  18:   78001022        ld.w       $w0,0(v0)
  1c:   79c10010        adds_u.w   $w0,$w0,$w1
  20:   7802e826        st.w       $w0,8(sp)
  24:   93a2000b        lbu        v0,11(sp)
  28:   03e00009        jr         ra
  2c:   27bd0038        addiu      sp,sp,56

Для полноты, GCC 6.3.0: 

MSA$ mips-img-linux-gnu-gcc.exe --version
mips-img-linux-gnu-gcc.exe (Codescape GNU Tools 2017.10-05 for MIPS IMG Linux) 6.3.0
Copyright (C) 2016 Free Software Foundation, Inc.
0 голосов
/ 21 октября 2018

Либо вы используете приведение и -flax-vector-conversions, либо используете тип объединения для представления векторных регистров и явно работаете с этим типом объединения.GCC явно поддерживает эту форму наказания типов.

Например, вы можете объявить тип msa128, 

typedef union __attribute__ ((aligned (16))) {
    v2u64   u64;
    v2i64   i64;
    v2f64   f64;
    v4u32   u32;
    v4i32   i32;
    v4f32   f32;
    v8u16   u16;
    v8i16   i16;
    v16u8   u8;
    v16i8   i8;
} msa128;

, а затем сделать так, чтобы ваш код явно работал с типом msa128,Ваша примерная программа может быть написана как 

    uint32_t a[4] = { 64, 128, 256, 512 };
    uint32_t b[4] = { 1024, 2048, 4096, 8192 };
    uint32_t c[4];
    msa128   va, vb, vc;

    va.i32 = __builtin_msa_ld_w(a, 0);
    vb.i32 = __builtin_msa_ld_w(b, 0);
    vc.u32 = __builtin_msa_adds_u_w(va.u32, vb.u32);
    __builtin_msa_st_w(vc.i32, c, 0);

Очевидно, что становится довольно неприятно вспоминать точный тип, который нужно использовать, поэтому некоторые статические встроенные вспомогательные функции определенно пригодятся: 

static inline msa128  msa128_load64(const void *from, const int imm)
{ return (msa128){ .i64 = __builtin_msa_ld_d(from, imm); } }

static inline msa128  msa128_load32(const void *from, const int imm)
{ return (msa128){ .i32 = __builtin_msa_ld_w(from, imm); } }

static inline msa128  msa128_load16(const void *from, const int imm)
{ return (msa128){ .i16 = __builtin_msa_ld_h(from, imm); } }

static inline msa128  msa128_load8(const void *from, const int imm)
{ return (msa128){ .i8  = __builtin_msa_ld_b(from, imm); } }

static inline void  msa128_store64(const msa128 val, void *to, const int imm)
{ __builtin_msa_st_d(val.i64, to, imm); }

static inline void  msa128_store32(const msa128 val, void *to, const int imm)
{ __builtin_msa_st_w(val.i32, to, imm); }

static inline void  msa128_store16(const msa128 val, void *to, const int imm)
{ __builtin_msa_st_h(val.i16, to, imm); }

static inline void  msa128_store8(const msa128 val, void *to, const int imm)
{ __builtin_msa_st_b(val.i8, to, imm); }

Например, бинарными операциями AND, OR, NOR и XOR являются 

static inline msa128  msa128_and(const msa128 a, const msa128 b)
{ return (msa128){ .u8 = __builtin_msa_and_v(a, b) }; }

static inline msa128  msa128_or(const msa128 a, const msa128 b)
{ return (msa128){ .u8 = __builtin_msa_or_v(a, b) }; }

static inline msa128  msa128_nor(const msa128 a, const msa128 b)
{ return (msa128){ .u8 = __builtin_msa_nor_v(a, b) }; }

static inline msa128  msa128_xor(const msa128 a, const msa128 b)
{ return (msa128){ .u8 = __builtin_msa_xor_v(a, b) }; }

Вероятно, не мешало бы создать некоторые макросы для представления векторов в виде массива: 

#define  MSA128_U64(...)  ((msa128){ .u64 = { __VA_ARGS__ }})
#define  MSA128_I64(...)  ((msa128){ .i64 = { __VA_ARGS__ }})
#define  MSA128_F64(...)  ((msa128){ .f64 = { __VA_ARGS__ }})
#define  MSA128_U32(...)  ((msa128){ .u32 = { __VA_ARGS__ }})
#define  MSA128_I32(...)  ((msa128){ .i32 = { __VA_ARGS__ }})
#define  MSA128_F32(...)  ((msa128){ .f32 = { __VA_ARGS__ }})
#define  MSA128_U16(...)  ((msa128){ .u16 = { __VA_ARGS__ }})
#define  MSA128_I16(...)  ((msa128){ .i16 = { __VA_ARGS__ }})
#define  MSA128_U8(...)   ((msa128){ .u8  = { __VA_ARGS__ }})
#define  MSA128_I8(...)   ((msa128){ .i8  = { __VA_ARGS__ }})

Причина, по которой я предлагаю этот специфичный для GCC подход, заключается в том, что встроенные функции в любом случае специфичны для GCC.Кроме типа объединения, это очень близко к тому, как GCC реализует векторные встроенные функции Intel / AMD в <immintrin.h>.

...