对 C99 可变长度数组 (VLA) 使用限制限定符

2024-01-08

我正在探索 C99 中简单循环的不同实现如何根据函数签名自动矢量化。

这是我的代码：

/* #define PRAGMA_SIMD _Pragma("simd") */
#define PRAGMA_SIMD

#ifdef __INTEL_COMPILER
#define ASSUME_ALIGNED(a) __assume_aligned(a,64)
#else
#define ASSUME_ALIGNED(a)
#endif

#ifndef ARRAY_RESTRICT
#define ARRAY_RESTRICT
#endif

void foo1(double * restrict a, const double * restrict b, const double * restrict c) 
{ 
    ASSUME_ALIGNED(a);
    ASSUME_ALIGNED(b);
    ASSUME_ALIGNED(c);
    PRAGMA_SIMD
    for (int i = 0; i < 2048; ++i) {
        if (c[i] > 0) {
            a[i] = b[i];
        } else {
            a[i] = 0.0;
        } 
    }
}

void foo2(double * restrict a, const double * restrict b, const double * restrict c) 
{ 
    ASSUME_ALIGNED(a);
    ASSUME_ALIGNED(b);
    ASSUME_ALIGNED(c);
    PRAGMA_SIMD
    for (int i = 0; i < 2048; ++i) {
        a[i] = ((c[i] > 0) ? b[i] : 0.0);
    }
}

/* Undetermined size version */

void foo3(int n, double * restrict a, const double * restrict b, const double * restrict c) 
{ 
    ASSUME_ALIGNED(a);
    ASSUME_ALIGNED(b);
    ASSUME_ALIGNED(c);
    PRAGMA_SIMD
    for (int i = 0; i < n; ++i) {
        if (c[i] > 0) {
            a[i] = b[i];
        } else {
            a[i] = 0.0;
        } 
    }
}

void foo4(int n, double * restrict a, const double * restrict b, const double * restrict c) 
{ 
    ASSUME_ALIGNED(a);
    ASSUME_ALIGNED(b);
    ASSUME_ALIGNED(c);
    PRAGMA_SIMD
    for (int i = 0; i < n; ++i) {
        a[i] = ((c[i] > 0) ? b[i] : 0.0);
    }
}

/* Static array versions */

void foo5(double ARRAY_RESTRICT a[2048], const double ARRAY_RESTRICT b[2048], const double ARRAY_RESTRICT c[2048]) 
{ 
    ASSUME_ALIGNED(a);
    ASSUME_ALIGNED(b);
    ASSUME_ALIGNED(c);
    PRAGMA_SIMD
    for (int i = 0; i < 2048; ++i) {
        if (c[i] > 0) {
            a[i] = b[i];
        } else {
            a[i] = 0.0;
        } 
    }
}

void foo6(double ARRAY_RESTRICT a[2048], const double ARRAY_RESTRICT b[2048], const double ARRAY_RESTRICT c[2048]) 
{ 
    ASSUME_ALIGNED(a);
    ASSUME_ALIGNED(b);
    ASSUME_ALIGNED(c);
    PRAGMA_SIMD
    for (int i = 0; i < 2048; ++i) {
        a[i] = ((c[i] > 0) ? b[i] : 0.0);
    }
}

/* VLA versions */

void foo7(int n, double ARRAY_RESTRICT a[n], const double ARRAY_RESTRICT b[n], const double ARRAY_RESTRICT c[n]) 
{ 
    ASSUME_ALIGNED(a);
    ASSUME_ALIGNED(b);
    ASSUME_ALIGNED(c);
    PRAGMA_SIMD
    for (int i = 0; i < n; ++i) {
        if (c[i] > 0) {
            a[i] = b[i];
        } else {
            a[i] = 0.0;
        } 
    }
}

void foo8(int n, double ARRAY_RESTRICT a[n], const double ARRAY_RESTRICT b[n], const double ARRAY_RESTRICT c[n]) 
{ 
    ASSUME_ALIGNED(a);
    ASSUME_ALIGNED(b);
    ASSUME_ALIGNED(c);
    PRAGMA_SIMD
    for (int i = 0; i < n; ++i) {
        a[i] = ((c[i] > 0) ? b[i] : 0.0);
    }
}

当我编译时

$ icc -O3 -std=c99 -opt-report5 -mavx -S foo.c 
icc: remark #10397: optimization reports are generated in *.optrpt files in the output location

我看到 VLA 案例没有自动矢量化，但是当我添加标志来断言没有混叠时-fno-alias，他们是。因此，我得出的结论是，我应该在源代码中规定这一点，因此我尝试通过编译来做到这一点

$ icc -O3 -std=c99 -opt-report5 -mavx -DARRAY_RESTRICT=restrict -S foo.c 
icc: remark #10397: optimization reports are generated in *.optrpt files in the output location

编译器错误输出包括

foo.c(98): error: "restrict" is not allowed
void foo7(int n, double ARRAY_RESTRICT a[n], const double ARRAY_RESTRICT b[n], 
const double ARRAY_RESTRICT c[n]) 

             ^

但正如您所看到的，我的 VLA 参数不允许限制。

所以我的问题是：有没有办法断言 ISO C 中 VLA 没有别名？

请注意，我可以使用编译指示在源代码中断言没有别名 - 例如simd, omp simd, ivdep等等 - 并获得我想要的自动矢量化，但这些不是 ISO C。

在这种情况下，ISO C 表示 C 的最新版本，当然在撰写本文时是 C11。

您的原始代码对我来说很失败，并显示以下消息：

 void foo7(int n, double ARRAY_RESTRICT a[n], const double ARRAY_RESTRICT b[n], const double ARRAY_RESTRICT c[n])
 ^
restrict.c:126:1: error: invalid use of ‘restrict’
restrict.c:126:1: error: invalid use of ‘restrict’
restrict.c:145:1: error: invalid use of ‘restrict’

^{Transferring selected parts of the comments}

§6.7.6.3函数声明符（包括原型）示例 5 表明以下函数原型声明符是等效的：

void f(double (* restrict a)[5]);
void f(double a[restrict][5]);
void f(double a[restrict 3][5]);
void f(double a[restrict static 3][5]);

这是标准中唯一出现与数组类型直接关联的限制的地方。 §6.7.6 通常用于声明符，而 §6.7.6.2 则用于数组声明符，在我看来，限制必须出现在数组维度的第一个组件内。根据您的情况，它应该是：

void foo7(int n, double a[ARRAY_RESTRICT n],
           const double b[ARRAY_RESTRICT n],
           const double c[ARRAY_RESTRICT n])

如果没有看到标准中的示例并且您提出问题，我不会相信这种符号！请注意，这适用于数组和 VLA。

根据注释修改后的代码在相同的编译选项下可以干净地编译：

gcc -g -O3 -std=c11 -Wall -Wextra -Wmissing-prototypes -Wstrict-prototypes \
    -Wold-style-definition -Wold-style-declaration -Werror -c new.restrict.c

编译选项要求事先声明非静态函数，因此声明位于文件顶部。我也强行#define ARRAY_RESTRICT restrict在源代码中，而不是将其保留为编译选项。

编译器是在 Ubuntu 14.04 衍生版本上运行的 GCC 4.9.2。

File new.restrict.c:

/* #define PRAGMA_SIMD _Pragma("simd") */
#define PRAGMA_SIMD

#ifdef __INTEL_COMPILER
#define ASSUME_ALIGNED(a) __assume_aligned(a, 64)
#else
#define ASSUME_ALIGNED(a)
#endif

#define ARRAY_RESTRICT restrict

#ifndef ARRAY_RESTRICT
#define ARRAY_RESTRICT
#endif

void foo1(double *restrict a, const double *restrict b, const double *restrict c);
void foo2(double *restrict a, const double *restrict b, const double *restrict c);
void foo3(int n, double *restrict a, const double *restrict b, const double *restrict c);
void foo4(int n, double *restrict a, const double *restrict b, const double *restrict c);
void foo5(double a[ARRAY_RESTRICT 2048], const double b[ARRAY_RESTRICT 2048], const double c[ARRAY_RESTRICT 2048]);
void foo6(double a[ARRAY_RESTRICT 2048], const double b[ARRAY_RESTRICT 2048], const double c[ARRAY_RESTRICT 2048]);
void foo7(int n, double a[ARRAY_RESTRICT n], const double b[ARRAY_RESTRICT n], const double c[ARRAY_RESTRICT n]);
void foo8(int n, double a[ARRAY_RESTRICT n], const double b[ARRAY_RESTRICT n], const double c[ARRAY_RESTRICT n]);

void foo1(double *restrict a, const double *restrict b, const double *restrict c)
{
    ASSUME_ALIGNED(a);
    ASSUME_ALIGNED(b);
    ASSUME_ALIGNED(c);
    PRAGMA_SIMD
    for (int i = 0; i < 2048; ++i)
    {
        if (c[i] > 0)
        {
            a[i] = b[i];
        }
        else
        {
            a[i] = 0.0;
        }
    }
}

void foo2(double *restrict a, const double *restrict b, const double *restrict c)
{
    ASSUME_ALIGNED(a);
    ASSUME_ALIGNED(b);
    ASSUME_ALIGNED(c);
    PRAGMA_SIMD
    for (int i = 0; i < 2048; ++i)
    {
        a[i] = ((c[i] > 0) ? b[i] : 0.0);
    }
}

/* Undetermined size version */

void foo3(int n, double *restrict a, const double *restrict b, const double *restrict c)
{
    ASSUME_ALIGNED(a);
    ASSUME_ALIGNED(b);
    ASSUME_ALIGNED(c);
    PRAGMA_SIMD
    for (int i = 0; i < n; ++i)
    {
        if (c[i] > 0)
        {
            a[i] = b[i];
        }
        else
        {
            a[i] = 0.0;
        }
    }
}

void foo4(int n, double *restrict a, const double *restrict b, const double *restrict c)
{
    ASSUME_ALIGNED(a);
    ASSUME_ALIGNED(b);
    ASSUME_ALIGNED(c);
    PRAGMA_SIMD
    for (int i = 0; i < n; ++i)
    {
        a[i] = ((c[i] > 0) ? b[i] : 0.0);
    }
}

/* Static array versions */

void foo5(double a[ARRAY_RESTRICT 2048], const double b[ARRAY_RESTRICT 2048], const double c[ARRAY_RESTRICT 2048])
{
    ASSUME_ALIGNED(a);
    ASSUME_ALIGNED(b);
    ASSUME_ALIGNED(c);
    PRAGMA_SIMD
    for (int i = 0; i < 2048; ++i)
    {
        if (c[i] > 0)
        {
            a[i] = b[i];
        }
        else
        {
            a[i] = 0.0;
        }
    }
}

void foo6(double a[ARRAY_RESTRICT 2048], const double b[ARRAY_RESTRICT 2048], const double c[ARRAY_RESTRICT 2048])
{
    ASSUME_ALIGNED(a);
    ASSUME_ALIGNED(b);
    ASSUME_ALIGNED(c);
    PRAGMA_SIMD
    for (int i = 0; i < 2048; ++i)
    {
        a[i] = ((c[i] > 0) ? b[i] : 0.0);
    }
}

/* VLA versions */

void foo7(int n, double a[ARRAY_RESTRICT n], const double b[ARRAY_RESTRICT n], const double c[ARRAY_RESTRICT n])
{
    ASSUME_ALIGNED(a);
    ASSUME_ALIGNED(b);
    ASSUME_ALIGNED(c);
    PRAGMA_SIMD
    for (int i = 0; i < n; ++i)
    {
        if (c[i] > 0)
        {
            a[i] = b[i];
        }
        else
        {
            a[i] = 0.0;
        }
    }
}

void foo8(int n, double a[ARRAY_RESTRICT n], const double b[ARRAY_RESTRICT n], const double c[ARRAY_RESTRICT n])
{
    ASSUME_ALIGNED(a);
    ASSUME_ALIGNED(b);
    ASSUME_ALIGNED(c);
    PRAGMA_SIMD
    for (int i = 0; i < n; ++i)
    {
        a[i] = ((c[i] > 0) ? b[i] : 0.0);
    }
}

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

C99

SIMD

variablelengtharray

restrictqualifier

autovectorization

对 C99 可变长度数组 (VLA) 使用限制限定符的相关文章

memcpy 在 Linux 中移动 128 位

我正在 Linux 中为 PCIe 设备编写设备驱动程序该设备驱动程序执行多次读取和写入来测试吞吐量当我使用 memcpy 时最大有效负载TLP https en wikipedia org wiki PCI Express Data
atexit 被认为有害吗？

使用是否存在固有的危险atexit在图书馆等大型项目中如果是这样背后的技术本质是什么 atexit这可能会导致大型项目出现问题我避免使用的主要原因atexit在图书馆中它的任何使用都涉及全局状态一个好的库应该避免拥有全局状态然而
C++中的restrict关键字是什么意思？

我总是不确定 restrict关键字在C 中意味着什么这是否意味着赋予函数的两个或多个指针不重叠还有什么意思呢在他的论文中内存优化 https web archive org web 20160422113037 http www
C，从单个输入行读取多个数字（scanf？）

我用 C 编写了一个应用程序需要输入两行第一个输入告诉 int 数组有多大第二个输入包含由空格分隔的值例如输入以下内容 5 1 2 3 4 99 应该创建一个包含 1 2 3 4 99 最快的方法是什么我的问题是读取多个数字而不
gcc(windows + MinGW) 是否在 inttypes.h 中定义了 SCNd8、SCNu8？

include
.c 文件中的 C99 内联函数

我在 c 中定义了我的函数没有标头声明如下所示 inline int func int i return i 1 然后在下面的同一个文件中我使用它 i func i 在链接过程中我得到了对 func 的未定义引用为什么 The i
使用指向单个值的指针作为数组

请注意该问题已针对注册变量进行了扩展简而言之我的问题是这个合法的 C 代码是否合法按照不同 ISO 9899 C 规范的标准字母最好在标准的文字中加上证明 int a 0 int b a 0 const int c 0 b
混洗两个 __m128i 的 64 位部分的最佳方法

我有两个 m128is a and b 我想进行洗牌以便高 64 位a落在低 64 位dst和低 64 位b落在上64dst i e dst 0 63 a 64 127 dst 64 127 b 0 63 相当于 m128i dst mm
使用 x64 SIMD 进行半字节改组

我知道字节改组 https www felixcloutier com x86 pshufb指令但我想对半字节 4 位值做同样的事情具体来说我想在 64 位字中混洗 16 个半字节我的洗牌索引也存储为 16 个半字节最有效的实施
如果 pragma STDC FENV_ACCESS 不存在，是否意味着默认舍入模式？

我对 C 标准的解释有疑问最新草案取自http www open std org jtc1 sc22 wg14 www docs n2454 pdf http www open std org jtc1 sc22 wg14 www doc
如何检索 C99 可变参数宏的最后一个参数？

Visual Studio 失败的 static assert 错误消息完全由错误代码和 static assert 的第二个参数组成没有任何其他消息表明这是静态断言失败我想做一个宏来解决这个问题例如作为第一次尝试 define S
size_t 的正确定义是什么？ [复制]

这个问题在这里已经有答案了首先我所说的正确的定义是什么意思例如 K R C 程序设计语言第二版在部分2 2 数据类型和大小对整数做出非常清楚的陈述有short int and long对于整数类型它们需要代表不同边界的值
C99 中带有 0 个参数的可变参数宏

我有一些调试代码如下所示 define STRINGIFY x x define TOSTRING x STRINGIFY x define AT FILE TOSTRING LINE void my error const char l
编译器如何解析在变长数组之后声明的变量的地址？

假设我有以下函数它使用可变长度数组 void func int size int var1 int arr size int var2 编译器如何确定地址var2 我能想到的唯一方法就是放置arr after var1 and var2
优化数组压缩

假设我有一个数组k 1 2 0 0 5 4 0 我可以按如下方式计算掩码m k gt 0 1 1 0 0 1 1 0 仅使用掩码 m 和以下操作左移右移 And Or 加减乘我可以将 k 压缩为以下形式 1 2 5 4 以下是我目
为什么在强度降低乘法和循环进位加法之后，这段代码的执行速度会变慢？

我正在读书阿格纳雾 https en wikipedia org wiki Agner Fog s 优化手册 https en wikipedia org wiki Agner Fog Optimization 我遇到了这个例子 doub
Visual Studio 2017 完全支持 C99 吗？

Visual Studio 的最新版本改进了对 C99 的支持最新版本VS2017现在支持所有C99吗如果没有 C99 还缺少哪些功能 No https learn microsoft com en us cpp visual cpp
有人为 MSP430 的 IAR Embedded Workbench 实现了 __getzone() 吗？

我必须在我的应用程序中处理一些时间转换我想尽可能坚持使用标准库函数现在我使用 time t 结构作为我的系统时间基准但是某些设备可以将时间同步到我的设备该时间可能是也可能不是 UTC 此外我的设备会将时间同步到另一台设备并且该
使用 _POSIX_C_SOURCE 2 的 Clang 未知类型名称“siginfo_t”，为什么？

Update结果我的讲师会接受按照 GNU99 标准编写的代码因此正如 User1 指出的那样我使用了 GNU SOURCE在我的节目开始时看man feature test macros了解更多信息感谢您帮助我理解在带有 Cl
关于 C99 函数参数中数组大小“保证”功能的实际优势？

C99 引入了一种新的函数参数表示法其中static关键字可用于指定参数至少有 N 个元素 6 7 6 3 函数声明符 p7 https port70 net 7Ensz c c11 n1570 html 6 7 6 3p7 将参数声明为

随机推荐

JavaScript for 循环问题

for循环可以重复一个数字3次吗例如 for i 0 i lt 5 i 创建 1 2 3 4 5 我想创建一个执行此操作的循环 1 1 1 2 2 2 3 3 3 4 4 4 5 5 5 那可能吗 for i 1 i lt 5 i for
获取 MethodBase 对象的最快方法是什么？

我有一个 Type 对象和一个方法名称 Type type string methodName 我需要一个方法 methodName 的 MethodBase 对象位于堆栈中的某个位置这有效 MethodBase nemo StackT
Detours - 挂钩类成员函数 - 设置目标函数偏移量的语法？

对于非类函数我可以简单地声明要绕行的函数的偏移量如下所示 typedef int cdecl SomeFunc char pBuffer int size SomeFunc Real SomeFunc SomeFunc 0xCAFEBA
在android中添加水印图像

我有代码可以在图像中添加水印如下所示 public static Bitmap mark Bitmap src String watermark Point location Color color int alpha int size
为什么 Edge 主体滚动条与 Firefox 主体滚动条不同？

我正在创建一个聊天列表它在 Firefox 上运行良好但在 Microsoft Edge 上却不起作用根的CSS div class chatting chatting position fixed bottom 5px right
将客户端证书传递给 Web 服务，而无需设置系统范围的属性

我正在尝试使用 JAX RPC 实现将客户端证书传递给 Web 服务 Web 服务采用 rpc 编码风格到目前为止我可以通过设置系统属性来做到这一点 System setProperty javax net ssl keyStore c
当用户尚未登录时，FB.ui() 在 Safari 中通过异步请求给出错误

我正在尝试让用户能够在我的外部网站上的 Facebook 墙上发布内容我在 Safari 中遇到问题如果用户未登录即他们尚未完成调用 FB login 的流程则在调用 FB ui 时会收到以下 JS 错误类型错误未定义不是对象
ServiceLoader.next 导致 NoClassDefFoundError

我这么问是因为我完全not我确信我做了正确的事我正在使用 Eclipse 进行 Web 项目我们在包中将其称为 WebProject 废话 com web project 我希望 WebProject 在运行时加载 JAR 插件所以我
上下文、AsyncTask 和轮换更改

这是一个很好的做法吗getApplicationContext 使用 AsyncTask 以便不必附加和分离 Activity以避免内存泄漏when发生旋转变化并且活动被破坏我认为它应该是正确的因为我实际上需要一个依赖于洞应用程序的上下
使用 Gmail 凭据登录

有没有一种方法可以使用 Google 凭据来获取基本用户信息例如电子邮件姓名性别并在我的应用程序中使用它们这就像允许用户使用 Gmail 登录我的应用程序一样我也问了同样的问题here https stackoverflow
ggplot2 二维密度权重

我正在尝试使用 R 中的 ggplot2 用二维密度轮廓绘制一些数据我得到一个有点奇怪的结果首先我设置了 ggplot 对象 p lt ggplot data aes x Distance y Rate colour Company
如何让 gVim 的 vimdiff 忽略大小写？

我正在尝试比较两个程序集文件其中一个文件全部大写另一个文件全部小写许多行在大小写和空格方面都是相同的我尝试了以下操作同时两个缓冲区处于差异模式 set diffopt icase set diffopt iwhite diffup
List.Add 似乎是重复的条目。怎么了？

我有一堂这样的课 public class myClass public List
计划任务的限制（或者任务持久化是如何实现的）？

我开始阅读 Hangfire 文档但没有发现任何有关任务限制的信息正如声明的那样任务或作业存储在某个地方由于它们只是代表据我所知唯一可以存储的东西是代表主体 IL 但是可能存在闭包它为任务提供了一些上下文例如一些外部服
如何在Python中对二进制文件进行base64编码/解码？

我正在尝试使用 python 使用以下简单代码对同一图像文件进行编码和解码但每次输出文件都大于输入文件并且无法打开这段代码有什么问题 import base64 with open img jpeg rb as image file e
多线程异常和Dispose。为什么 Dispose 没有调用？

using 语句保证该对象将被调用 Dispose 方法在此示例中这种情况没有发生并且终结器方法也没有调用为什么这一切当其他线程发生异常时如何更改代码以保证处理我的对象 class Program static void Mai
JavaScript 中的动态方法调用

我知道我可以这样做 var myClass my class definition var methodName myMethod myClass methodName p1 p2 pN 但如果有这样的情况我该怎么办 if data som
在 tkinter 画布上绘制 png 图像 python

我正在尝试使用创建一个简单的游戏tkinter in python 3 5使用画布小部件对于这个游戏我需要能够使用透明 png 图像这是我的代码 from PIL import ImageTk from tkinter import
我可以使用 PHP 读取 .TXT 文件吗？

当我开始使用 PHP 和 MySQL 编写站点时我编写的第一个 PHP 脚本之一是初始化数据库的脚本删除创建数据库删除创建每个表然后从脚本中的文字加载表一切正常呼呼但我更喜欢从文件中读取数据而不是在 PHP 脚本中对它们
对 C99 可变长度数组 (VLA) 使用限制限定符

我正在探索 C99 中简单循环的不同实现如何根据函数签名自动矢量化这是我的代码 define PRAGMA SIMD Pragma simd define PRAGMA SIMD ifdef INTEL COMPILER define A

对 C99 可变长度数组 (VLA) 使用限制限定符

对 C99 可变长度数组 (VLA) 使用限制限定符 的相关文章

随机推荐

热门标签

对 C99 可变长度数组 (VLA) 使用限制限定符的相关文章