gcc - SIMD 寄存器的数学函数-6ren

gcc - SIMD 寄存器的数学函数

转载作者：行者123 更新时间：2023-12-04 02:09:08

根据https://sourceware.org/glibc/wiki/libmvec GCC 具有数学函数的向量实现。它们可以被编译器用于优化，可以在这个例子中看到:https://godbolt.org/g/IcxtVi , 编译器使用一些重整的正弦函数并且一次操作 4 个 double

我知道如果我需要数学函数可以使用 SIMD 数学库，但我仍然感兴趣是否有一种方法可以手动调用 GCC 中已经存在的向量化数学函数 __m256d具有某种内在或任何其他方式的变量？

最佳答案

Libmvec 是一个 x86_64 glibc 库，具有 SSE4、AVX、AVX2 和 AVX-512 矢量化函数cos , exp , log , sin , pow , 和 sincos ，单精度和 double 。
这些函数的精度为 4-ulp 最大相对误差。

通常 gcc 会插入对 Libmvec 函数的调用，例如 _ZGVdN4v_cos ,
虽然它是自动矢量化标量代码，例如 -ffast-math或者#pragma omp simd .然而，这些向量函数也适用于
手动矢量化 C 代码。
不幸的是 Libmvec document
没有给出很多例子来解释如何使用这些函数
手动矢量化 C 代码。

要使用 Libmvec 函数，必须包含函数声明
并将代码与 -lm 链接(与数学库链接)选项。
链接器不需要 -lmvec ，链接标准数学库-lm是
足以用于非静态构建，请参阅 here .-ffast-math编译器选项不是必需的。

以下示例显示如何调用 AVX2 矢量化函数。
此示例在标准 Ubuntu 18.04 系统(glibc 版本 2.27)上成功运行。

/* gcc -Wall -O3 -m64 -march=skylake libmvec_ex.c -lm */ 
#include <immintrin.h>
#include <stdio.h>
#include <stdint.h>
#define _GNU_SOURCE      /* These two lines are optional. They are only needed to use the scalar */
#include <math.h>        /* functions sin, exp, sincos,...                                       */

__m256d _ZGVdN4v_cos(__m256d x);                    
__m256d _ZGVdN4v_exp(__m256d x);                    
__m256d _ZGVdN4v_log(__m256d x);                    
__m256d _ZGVdN4v_sin(__m256d x);                    
__m256d _ZGVdN4vv_pow(__m256d x, __m256d y); 
void    _ZGVdN4vvv_sincos(__m256d x, __m256i ptrs, __m256i ptrc);

__m256  _ZGVdN8v_cosf(__m256 x);            
__m256  _ZGVdN8v_expf(__m256 x);            
__m256  _ZGVdN8v_logf(__m256 x);            
__m256  _ZGVdN8v_sinf(__m256 x);            
__m256  _ZGVdN8vv_powf(__m256 x, __m256 y); 
void    _ZGVdN8vvv_sincosf(__m256 x, __m256i ptrs_lo, __m256i ptrs_hi, __m256i ptrc_lo, __m256i ptrc_hi);

int mm256_print_pd(__m256d x);
int mm256_print_ps(__m256 x);

int main()
{
  __m256d x, y, z;
  __m256 xf, yf, zf;
  double z_s[4], z_c[4];          /* sincos output                              */
  float zf_s[8], zf_c[8];         /* sincosf output                             */
  __m256i ptrs, ptrc;             /* Pointers to the elements of z_s and z_c    */ 
  __m256i ptrs_lo, ptrs_hi, ptrc_lo, ptrc_hi;

  x = _mm256_set_pd (0.04, 0.03, 0.02, 0.01);
  y = _mm256_set_pd (2.0, 1.5, 1.0, 0.5);
  xf = _mm256_set_ps (0.08f, 0.07f, 0.06f, 0.05f, 0.04f, 0.03f, 0.02f, 0.01f);
  yf = _mm256_set_ps (4.0f, 3.5f, 3.0f, 2.5f, 2.0f, 1.5f, 1.0f, 0.5f);

  printf("AVX2 Double precision examples\n");
                             printf("x             "); mm256_print_pd(x);
                             printf("y             "); mm256_print_pd(y);
  z =_ZGVdN4v_cos(x);        printf("cos(x)        "); mm256_print_pd(z);
  z =_ZGVdN4v_exp(x);        printf("exp(x)        "); mm256_print_pd(z);
  z =_ZGVdN4v_log(x);        printf("log(x)        "); mm256_print_pd(z);
  z =_ZGVdN4v_sin(x);        printf("sin(x)        "); mm256_print_pd(z);
  z =_ZGVdN4vv_pow(x, y);    printf("pow(x,y)      "); mm256_print_pd(z);

  ptrs = _mm256_set_epi64x((uint64_t)&z_s[3],(uint64_t)&z_s[2],(uint64_t)&z_s[1],(uint64_t)&z_s[0]);
  ptrc = _mm256_set_epi64x((uint64_t)&z_c[3],(uint64_t)&z_c[2],(uint64_t)&z_c[1],(uint64_t)&z_c[0]);
/* Alternative: ptrs = _mm256_add_epi64(_mm256_set1_epi64x((uint64_t)&z_s[0]),_mm256_set_epi64x(24,16,8,0));  */
/* This might be more efficient if the destination addresses are contiguous in memory.                        */
  _ZGVdN4vvv_sincos(x, ptrs, ptrc);                                 /* The results of _ZGVdN4vvv_sincos are scattered into the adresses in ptrs and ptrc */ 
  printf("sincos cos(x) %12.8f %12.8f %12.8f %12.8f  \n", z_c[3], z_c[2], z_c[1], z_c[0]);
  printf("sincos sin(x) %12.8f %12.8f %12.8f %12.8f\n\n", z_s[3], z_s[2], z_s[1], z_s[0]);

  printf("AVX2 Single precision examples\n");
                             printf("x             "); mm256_print_ps(xf);
                             printf("y             "); mm256_print_ps(yf);
  zf =_ZGVdN8v_cosf(xf);     printf("cosf(x)       "); mm256_print_ps(zf);
  zf =_ZGVdN8v_expf(xf);     printf("expf(x)       "); mm256_print_ps(zf);
  zf =_ZGVdN8v_logf(xf);     printf("logf(x)       "); mm256_print_ps(zf);
  zf =_ZGVdN8v_sinf(xf);     printf("sinf(x)       "); mm256_print_ps(zf);
  zf =_ZGVdN8vv_powf(xf, yf);printf("powf(x,y)     "); mm256_print_ps(zf);

  ptrs_lo = _mm256_set_epi64x((uint64_t)&zf_s[3],(uint64_t)&zf_s[2],(uint64_t)&zf_s[1],(uint64_t)&zf_s[0]);
  ptrs_hi = _mm256_set_epi64x((uint64_t)&zf_s[7],(uint64_t)&zf_s[6],(uint64_t)&zf_s[5],(uint64_t)&zf_s[4]);
  ptrc_lo = _mm256_set_epi64x((uint64_t)&zf_c[3],(uint64_t)&zf_c[2],(uint64_t)&zf_c[1],(uint64_t)&zf_c[0]);
  ptrc_hi = _mm256_set_epi64x((uint64_t)&zf_c[7],(uint64_t)&zf_c[6],(uint64_t)&zf_c[5],(uint64_t)&zf_c[4]);
  _ZGVdN8vvv_sincosf(xf, ptrs_lo, ptrs_hi, ptrc_lo, ptrc_hi);       /* The results of _ZGVdN8vvv_sincosf are scattered to the adresses in ptrs_lo, ptrs_hi, ptrc_lo, and ptrc_hi */ 
  printf("sincosf cos(x)%12.8f %12.8f %12.8f %12.8f %12.8f %12.8f %12.8f %12.8f \n", 
           zf_c[7], zf_c[6], zf_c[5], zf_c[4], zf_c[3], zf_c[2], zf_c[1], zf_c[0]);
  printf("sincosf sin(x)%12.8f %12.8f %12.8f %12.8f %12.8f %12.8f %12.8f %12.8f  \n",
           zf_s[7], zf_s[6], zf_s[5], zf_s[4], zf_s[3], zf_s[2], zf_s[1], zf_s[0]);

  return 0;
}


__attribute__ ((noinline)) int mm256_print_pd(__m256d x){
    double vec_x[4];
    _mm256_storeu_pd(vec_x,x);
    printf("%12.8f %12.8f %12.8f %12.8f  \n", vec_x[3], vec_x[2], vec_x[1], vec_x[0]);
    return 0;
}


__attribute__ ((noinline)) int mm256_print_ps(__m256 x){
    float vec_x[8];
    _mm256_storeu_ps(vec_x,x);
    printf("%12.8f %12.8f %12.8f %12.8f %12.8f %12.8f %12.8f %12.8f \n", vec_x[7], vec_x[6], vec_x[5], vec_x[4],
                     vec_x[3], vec_x[2], vec_x[1], vec_x[0]);
    return 0;
}
/*

输出如预期:

$ ./a.out
AVX2 Double precision examples
x               0.04000000   0.03000000   0.02000000   0.01000000  
y               2.00000000   1.50000000   1.00000000   0.50000000  
cos(x)          0.99920011   0.99955003   0.99980001   0.99995000  
exp(x)          1.04081077   1.03045453   1.02020134   1.01005017  
log(x)         -3.21887582  -3.50655790  -3.91202301  -4.60517019  
sin(x)          0.03998933   0.02999550   0.01999867   0.00999983  
pow(x,y)        0.00160000   0.00519615   0.02000000   0.10000000  
sincos cos(x)   0.99920011   0.99955003   0.99980001   0.99995000  
sincos sin(x)   0.03998933   0.02999550   0.01999867   0.00999983

AVX2 Single precision examples
x               0.08000000   0.07000000   0.06000000   0.05000000   0.04000000   0.03000000   0.02000000   0.01000000 
y               4.00000000   3.50000000   3.00000000   2.50000000   2.00000000   1.50000000   1.00000000   0.50000000 
cosf(x)         0.99680173   0.99755102   0.99820060   0.99875027   0.99920011   0.99955004   0.99979997   0.99995005 
expf(x)         1.08328700   1.07250810   1.06183648   1.05127108   1.04081070   1.03045452   1.02020133   1.01005018 
logf(x)        -2.52572870  -2.65926003  -2.81341076  -2.99573231  -3.21887589  -3.50655794  -3.91202307  -4.60517025 
sinf(x)         0.07991469   0.06994285   0.05996400   0.04997917   0.03998933   0.02999550   0.01999867   0.00999983 
powf(x,y)       0.00004096   0.00009075   0.00021600   0.00055902   0.00160000   0.00519615   0.02000000   0.10000000 
sincosf cos(x)  0.99680173   0.99755102   0.99820060   0.99875027   0.99920011   0.99955004   0.99979997   0.99995005 
sincosf sin(x)  0.07991469   0.06994285   0.05996400   0.04997917   0.03998933   0.02999550   0.01999867   0.00999983

请注意，矢量化 sincos函数将结果分散到 4(双)或
8(浮点)，不一定是连续的内存位置。

SSE4、AVX 和 AVX2 的函数声明，以及英特尔 SVML 替代方案。

下面的代码块显示了许多不同情况的函数声明，
以及来自英特尔 SVML 库的相应 SVML 函数。
不知何故，我找不到这些带有正确参数列表的声明，
在互联网上。

/* Double precision Libmvec                        Intel SVML function                     */

/* SSE4                                                                                    */
__m128d _ZGVbN2v_cos(__m128d x);               /*  _mm_cos_pd(x)                           */
__m128d _ZGVbN2v_exp(__m128d x);               /*  _mm_exp_pd(x)                           */ 
__m128d _ZGVbN2v_log(__m128d x);               /*  _mm_log_pd(x)                           */
__m128d _ZGVbN2v_sin(__m128d x);               /*  _mm_sin_pd(x)                           */ 
__m128d _ZGVbN2vv_pow(__m128d x, __m128d y);   /*  _mm_pow_pd(x, y)                        */
void    _ZGVbN2vvv_sincos(__m128d x, __m128i ptrs, __m128i ptrc);    /* _mm_sincos_pd      */
/* AVX                                                                                     */
__m256d _ZGVcN4v_cos(__m256d x);               /*  _mm256_cos_pd(x)                        */
__m256d _ZGVcN4v_exp(__m256d x);               /*  _mm256_exp_pd(x)                        */ 
__m256d _ZGVcN4v_log(__m256d x);               /*  _mm256_log_pd(x)                        */
__m256d _ZGVcN4v_sin(__m256d x);               /*  _mm256_sin_pd(x)                        */ 
__m256d _ZGVcN4vv_pow(__m256d x, __m256d y);   /*  _mm256_pow_pd(x, y)                     */ 
void    _ZGVcN4vvv_sincos(__m256d x, __m256i ptrs, __m256i ptrc);    /* _mm256_sincos_pd   */
/* AVX2                                                                                    */
__m256d _ZGVdN4v_cos(__m256d x);               /*  _mm256_cos_pd(x)                        */
__m256d _ZGVdN4v_exp(__m256d x);               /*  _mm256_exp_pd(x)                        */ 
__m256d _ZGVdN4v_log(__m256d x);               /*  _mm256_log_pd(x)                        */
__m256d _ZGVdN4v_sin(__m256d x);               /*  _mm256_sin_pd(x)                        */ 
__m256d _ZGVdN4vv_pow(__m256d x, __m256d y);   /*  _mm256_pow_pd(x, y)                     */
void    _ZGVdN4vvv_sincos(__m256d x, __m256i ptrs, __m256i ptrc);    /* _mm256_sincos_pd   */


/* Single precision Libmvec                       Intel SVML function                      */

/* SSE4                                                                                    */
__m128  _ZGVbN4v_cosf(__m128 x);               /* _mm_cos_ps(x)                            */
__m128  _ZGVbN4v_expf(__m128 x);               /* _mm_exp_ps(x)                            */ 
__m128  _ZGVbN4v_logf(__m128 x);               /* _mm_log_ps(x)                            */
__m128  _ZGVbN4v_sinf(__m128 x);               /* _mm_sin_ps(x)                            */ 
__m128  _ZGVbN4vv_powf(__m128 x, __m128 y);    /* _mm_pow_ps(x, y) */ 
void    _ZGVbN4vvv_sincosf(__m128 x, __m128i ptrs_lo, __m128i ptrs_hi, __m128i ptrc_lo, __m128i ptrc_hi);      /* _mm_sincos_ps   */
/* AVX                                                                                     */
__m256  _ZGVcN8v_cosf(__m256 x);               /* _mm256_cos_ps(x)                         */
__m256  _ZGVcN8v_expf(__m256 x);               /* _mm256_exp_ps(x)                         */ 
__m256  _ZGVcN8v_logf(__m256 x);               /* _mm256_log_ps(x)                         */
__m256  _ZGVcN8v_sinf(__m256 x);               /* _mm256_sin_ps(x)                         */ 
__m256  _ZGVcN8vv_powf(__m256 x, __m256 y);    /* _mm256_pow_ps(x, y)                      */ 
void    _ZGVcN8vvv_sincosf(__m256 x, __m256i ptrs_lo, __m256i ptrs_hi, __m256i ptrc_lo, __m256i ptrc_hi);      /* _mm256_sincos_ps   */
/* AVX2                                                                                    */
__m256  _ZGVdN8v_cosf(__m256 x);               /* _mm256_cos_ps(x)                         */
__m256  _ZGVdN8v_expf(__m256 x);               /* _mm256_exp_ps(x)                         */ 
__m256  _ZGVdN8v_logf(__m256 x);               /* _mm256_log_ps(x)                         */
__m256  _ZGVdN8v_sinf(__m256 x);               /* _mm256_sin_ps(x)                         */ 
__m256  _ZGVdN8vv_powf(__m256 x, __m256 y);    /* _mm256_pow_ps(x, y)                      */
void    _ZGVdN8vvv_sincosf(__m256 x, __m256i ptrs_lo, __m256i ptrs_hi, __m256i ptrc_lo, __m256i ptrc_hi);      /* _mm256_sincos_ps   */

/* Note that I only tested the AVX2 function declarations.                                 */
/* AVX-512: _ZGVeN16v_cosf, _ZGVeN8v_cos etc.                                              */

有用的链接:

https://sourceware.org/glibc/wiki/libmvec

https://sourceware.org/glibc/wiki/libmvec?action=AttachFile&do=view&target=VectorABI.txt

https://github.com/sgallagher/glibc/blob/master/sysdeps/unix/sysv/linux/x86_64/libmvec.abilist

https://software.intel.com/sites/default/files/managed/b4/c8/Intel-Vector-Function-ABI.pdf

关于gcc - SIMD 寄存器的数学函数，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/40475140/

文章推荐： sql-server - "Estimated Number of Executions"膨胀了

文章推荐： sql - PL/SQL Oracle 目录

文章推荐： html - getContext ('2d' ) 在 Safari 10 中返回 null

文章推荐： php - 密码重置表列名称覆盖 laravel 5

assembly - 字大小的 OUT 到字节 IO 寄存器？使用旧 VGA 代码中的指令设置序列 Controller 寄存器
我无法理解如何使用一些旧的 VGA 代码在这个示例中设置序列 Controller 寄存器: mov dx,SC_INDEX mov ax,0604h out dx,ax
assembly - 如何将 AVX512 寄存器 zmm26 中的 QuadWord 写入 rax 寄存器？
我希望对 zmm 0-31 寄存器集的四字元素执行整数算术运算并保留这些运算产生的进位位。看来这只有在通用寄存器集中处理数据时才有可能。因此，我想将信息从 zmm 0-31 寄存器之一复制到通用寄存
一文搞懂ARM64系列:寄存器
ARM 64中包含多种寄存器，下面介绍一些常见的寄存器。 1 通用寄存器 ARM 64包含31个64bit寄存器，记为X0~X30。每一个通用寄存器，它的低32bit都可以被访问，记为W0~W
09-寄存器
1.寄存器组合逻辑存在一个最大的缺点就是存在竞争与冒险,系统会产生不定态;使用时序逻辑电路就会极大的改善这种情况寄存器具有存储功能,一般是由D触发器构成,由时钟脉冲控制,每个D触发器能够
MIPS $gp 寄存器
使用 $gp 是否存在危险？注册以存储值？我想我的问题是 $gp 的真正功能是什么？它是否以某种方式在幕后调用，以便如果我使用它，事情可能会变得非常非常错误？最佳答案那么，$gp register
PHP:$_SESSION 寄存器
我遇到了这段代码的问题，我无法弄清楚问题出在哪里。所以当我运行这段代码时:if $row["count"] > 0 else块运行和 $_SESSION["error"]设置。当$row["coun
assembly - 如何找出逆向工程汇编中的第二个参数/寄存器？
所以我正在做二进制炸弹的变体。这就是阶段 0x0000000000401205 : sub $0x8,%rsp 0x0000000000401209 : cmp $0x3,
sql - 寄存器 0x104567911
我在一个名为 (EmployeeDetailKey - varchar(10)) 的字段中获得了一个值，其中包含顺序值，例如 00001, 00002, 00003.... 它位于 Employeed
java - 寄存器 0x104567911
我有一个要求，应该为每个调用的线程分配一个计数器变量。但我没有得到预期的结果，实际上计数器在线程中重复。我创建了一个虚拟表和一个过程来将计数器值插入到表中。无论如何，是否可以更改代码以便线程获得递增的
php - 寄存器 0x104567911
预期输出:需要打印第4季度的wage_amt +--------------+--------------+--------------+--------------+ | wages_amt_q1
javascript - 寄存器 0x104567911
如何匹配模式 abc_[someArbitaryStringHere]_xyz？为了澄清，我希望正则表达式能够匹配以下性质的字符串: abc_xyz、abc_asdfsdf_xyz、abc_32rw
css - 寄存器 0x104567911
从下拉列表(自定义)中选择一个值而不是常规下拉列表，它有很多下拉值我可以用代码选择第一个值 find('.selected', :text=>arg1,exact: false).click 但无法
c - 恢复用户堆栈/寄存器
这个问题不太可能帮助任何 future 的访问者；它只与一个小的地理区域、一个特定的时间点或一个非常狭窄的情况有关，这些情况并不普遍适用于互联网的全局受众。为了帮助使这个问题更广泛地适用，visit
python - 寄存器 0x104567911
我有 .csv 文件中的数据，它包含 2 列 x 轴和 y 轴。从 .csv 文件读取轴，然后使用拉伸(stretch)指数函数拟合数据，但显示错误。这里我给出示例数据以方便理解。我的函数是f(x
assembly - 为什么循环不递减 cx 寄存器？
我正在尝试使用以下汇编代码将磁盘扇区加载到内存中，但正如我在终端中使用一些 int 0x10 时发现的那样，它不起作用的原因是它陷入了无限循环。我以为循环会自动为我递减 cx 寄存器。下面是代码，其中
vim - 从终端命令行复制一行到 vim 寄存器
我正在尝试编写一个脚本，该脚本将在 vim 中打开一个文件并将其中的特定行复制到 vim 的寄存器之一中。当脚本再次运行时，它会决定再次打开文件，然后将 vim 寄存器中的值粘贴回。实际上，脚本应该在
assembly - 从内存中添加一个字节到 AX 寄存器
我目前正在尝试弄清楚如何将指针寄存器 SI 指向的内存中的第一个字节添加到 AX 寄存器的当前内容中。因此，如果 SI 包含某个地址，并且该地址在内存中的值是:00 和 01，我希望将 00 添加到
assembly - 将两个数字放入 EAX 寄存器
我试图将两个 16 位数字与以下 NASM 代码相乘: mov ax, [input1] mov bx, [input2] mul bx 前面代码的结果存储在 DX:AX 我试图使用来自单独库“pri
c - 从内联汇编修改 RIP 寄存器
我正在尝试修改 rip 寄存器(只是为了好玩)。 buffer 应该是内存地址，所以不知道为什么会得到Error: operand type mismatch for 'movq' #include
gcc - 在内联汇编中使用特定的 zmm 寄存器
我可以告诉gcc-style inline assembly把我的__m512i变量到特定 zmm注册，如 zmm31 ？最佳答案就像在根本没有特定寄存器约束的目标(如 ARM)上一样，使用 lo

行者123

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城

gcc - SIMD 寄存器的数学函数