C進階指南（3）：顯式內聯、向量擴充套件、C的逸聞軼事

醉酒屠夫發表於2014-07-09

前兩篇：

五、顯式內聯

（想讓）函式程式碼被直接整合到呼叫函式中，而非產生獨立的函式目標和單個呼叫，可顯式地使用 inline 限定符來指示編譯器這麼做。根據 section 6.7.4 of C standard inline 限定符僅建議編譯器使得”呼叫要儘可能快”，並且“此建議是否有效由具體實現定義”

要用行內函數優點的最簡單方法是把函式定義為 static ，然後將定義放入標頭檔案。

/* middle.h */
static inline int middle(int a, int b){
    return (b-a)/2;
}

/* middle.h */

static inline int middle(int a, int b){

return (b-a)/2;

}

獨立的函式物件仍然可能被匯出，但在翻譯單元的外部它是不可見的。這種標頭檔案被包含在多個翻譯單元中，編譯器可能為每個單元發射函式的多份拷貝。因此，有可能兩個變數指向相同的函式名，指標的值可能不相等。

另一種方法是，既提供外部可連線的版本，也提供內聯版本，兩個版本功能相同，讓編譯器決定使用哪個。這實際上是內嵌限定符的定義：

If all of the file scope declarations for a function in a translation unit include the inline function specifier without extern, then the definition in that translation unit is an inline definition. An inline definition does not provide an external definition for the function, and does not forbid an external definition in another translation unit. An inline definition provides an alternative to an external definition, which a translator may use to implement any call to the function in the same translation unit. It is unspecified whether a call to the function uses the inline definition or the external definition.

在一個翻譯單元中，若某個函式在所有的檔案範圍內都包含不帶extern的行內函數限定符，則此翻譯單元中此函式定義是內聯定義。內聯定義不為函式提供外部的定義，也不禁止其他翻譯單元的外部定義。內聯定義為外部定義提供一個可選項，在同一翻譯單元內翻譯器可用它實現對函式的任意呼叫。呼叫函式時，使用內聯定義或外聯定義是不確定的。

（譯者注：即gcc中的 extern inline，優先使用內聯版本，允許外部版本的存在）

對於函式的兩個版本，我們可以把下面的定義放在標頭檔案中：

/* middle.h */
inline int middle(int a, int b){
    return (b-a)/2;
}

/* middle.h */

inline int middle(int a, int b){

return (b-a)/2;

}

然後在具體的原始檔中，用extern限定符發射翻譯單元中外部可連結的版本：

#include "middle.h"
extern int middle(int a, int b);

1 2	#include "middle.h" extern int middle(int a, int b);

GCC編譯器的實現不同於上述譯碼方式。若函式由 inline 宣告，GCC總是發射外部可連結的目的碼，並且程式中只存在一個這樣的定義。若函式被宣告為export inline的，GCC將永不為此函式發射外部可連結的目的碼。自GCC 4.3版本起，可使用-STD= c99的選項使能為內聯定義使能C99規則。若C99的規則被啟用，則定義GNUC_STDC_INLINE。之前描述的 static 使用方法不受GCC對行內函數解釋的影響。如果你需要同時使用內聯和外部可連結功能的函式，可考慮以下解決方案：

/* global.h */
#ifndef INLINE
# if __GNUC__ && !__GNUC_STDC_INLINE__
#  define INLINE extern inline
# else
#  define INLINE inline
# endif
#endif

/* global.h */

#ifndef INLINE

# if __GNUC__ && !__GNUC_STDC_INLINE__

# define INLINE extern inline

# else

# define INLINE inline

# endif

#endif

標頭檔案中有函式定義：

/* middle.h  */
#include "global.h"
INLINE int middle(int a, int b) {
  return (b-a)/2;
}

/* middle.h */

#include "global.h"

INLINE int middle(int a, int b) {

return (b-a)/2;

}

在某個具體實現的原始檔中：

#define INLINE
#include "middle.h

1 2	#define INLINE #include "middle.h

若要對函式強制執行內聯，GCC和Clang編譯器都可用 always_inline 屬性達成此目的。下面的例子中，獨立的函式物件從未被髮射。

/* cdefs.h */
# define __always_inline   inline __attribute__((always_inline))

/* middle.h */
#include &lt;cdefs.h&gt;
static __always_inline int middle(int a, int b) {
  return (b-a)/2;
}

/* cdefs.h */

# define __always_inline inline __attribute__((always_inline))

/* middle.h */

#include <cdefs.h>

static __always_inline int middle(int a, int b) {

return (b-a)/2;

}

一旦編譯器內聯失敗，編譯將因錯誤而終止。例如 Linux kernel 就使用這種方法。可在 cdefs.h 中上述程式碼中使用的 __always_inline 。

六、向量擴充套件

許多微處理器（特別是x86架構的）提供單指令多資料（SIMD）指令集來使能向量操作。例如下面的程式碼：

#include <stdint.h>
#include <string.h>
#define SIZE 8
int16_t a[SIZE], b[SIZE];

void addtwo(){
    int16_t i = 0;

    while (i < SIZE) {
        a[i] = b[i] + 2;
        i++;
    }
}

int main(){
    addtwo();
    return a[0];
}

#include <stdint.h>

#include <string.h>

#define SIZE 8

int16_t a[SIZE], b[SIZE];

void addtwo(){

int16_t i = 0;

while (i < SIZE) {

a[i] = b[i] + 2;

i++;

}

int main(){

addtwo();

return a[0];

}

addtwo 中的迴圈迭代 8 次，每次往陣列 b 上加 2，陣列 b 每個元素是 16 位的有符號整型。函式 addtwo 將被編譯成下面的彙編程式碼：

$ gcc -O2 auto.c -S -o auto_no.asm

1	$ gcc -O2 auto.c -S -o auto_no.asm

addtwo:
.LFB22:
        .cfi_startproc
        movl    $0, %eax
.L2:
        movzwl  b(%rax), %edx
        addl    $2, %edx
        movw    %dx, a(%rax)
        addq    $2, %rax
        cmpq    $16, %rax
        jne     .L2
        rep
        ret
        .cfi_endproc

addtwo:

.LFB22:

.cfi_startproc

movl $0, %eax

.L2:

movzwl b(%rax), %edx

addl $2, %edx

movw %dx, a(%rax)

addq $2, %rax

cmpq $16, %rax

jne .L2

rep

ret

.cfi_endproc

起初，0 寫入到 eax 暫存器。標籤 L2 標著迴圈的開始。b 的首個元素由 movzwl 指令被裝入的32位暫存器 edx 前16位。 edx暫存器的其餘部分填 0。然後 addl 指令往 edx 暫存器中 a 的第一個元素的值加 2 並將結果存在 dx 暫存器中。累加結果從 dx（edx 暫存器的低16位）複製到 a 的第一個元素。最後，顯然存放了步長為 2 （佔2個位元組 – 16位）的陣列的 rax 暫存器與陣列的總大小（以位元組為單位）進行比較。如果 rax 不等於16，執行跳到 L2 ，否則會繼續執行，函式返回。

SSE2 指令集提供了能夠一次性給 8 個 16 位整型做加法的指令 paddw。實際上，最現代化的編譯器都能夠自動使用如 paddw 之類的向量指令優化程式碼。Clang 預設啟用自動向量化。 GCC的編譯器中可用 -ftree-vectorize 或 -O3 開關啟用它。這樣一來，向量指令優化後的 addtwo 函式彙編程式碼將會大有不同：

$ gcc -O2 -msse -msse2 -ftree-vectorize -ftree-vectorizer-verbose=5 auto.c -S -o auto.asm

1	$ gcc -O2 -msse -msse2 -ftree-vectorize -ftree-vectorizer-verbose=5 auto.c -S -o auto.asm

addtwo:
.LFB22:
        .cfi_startproc
        movdqa  .LC0(%rip), %xmm0
        paddw   b(%rip), %xmm0
        movdqa  %xmm0, a(%rip)
        ret
        .cfi_endproc

;...

.LC0:
        .value  2
        .value  2
        .value  2
        .value  2
        .value  2
        .value  2
        .value  2
        .value  2

addtwo:

.LFB22:

.cfi_startproc

movdqa .LC0(%rip), %xmm0

paddw b(%rip), %xmm0

movdqa %xmm0, a(%rip)

ret

.cfi_endproc

;...

.LC0:

.value 2

最顯著的區別在於迴圈處理消失了。首先，8 個 16 位值為 2 整數被標記為 LC0，由 movdqa 載入到 xmm0 暫存器。然後paddw 把 b 的每個 16 位的元素分別加到 xmm0 中的多個數值 2上。結果寫回到 a，函式可以返回。指令 movqda 只能用在由16個位元組對齊的記憶體物件上。這表明編譯器能夠對齊兩個陣列的記憶體地址以提高效率。

陣列的大小不必一定只是 8 個元素，但它必須以 16 位元組對齊（需要的話，填充），因此也可以用 128 位向量。用行內函數也可能是一個好主意，特別是當陣列作為引數傳遞的時候。因為陣列被轉換為指標，指標地址需要16位元組對齊。如果函式是內聯的，編譯器也許能減少額外的對齊開銷。

#include <stdint.h>

void __always_inline addtwo(int16_t* a, int16_t *b, int16_t size){
    int16_t i;

    for (i = 0; i < size; i++) {
        a[i] = b[i] + 2;
    }
}

int main(){
    const int16_t size = 1024;
    int16_t a[size], b[size];

    addtwo(a, b, size);
    return a[0];
}

#include <stdint.h>

void __always_inline addtwo(int16_t* a, int16_t *b, int16_t size){

int16_t i;

for (i = 0; i < size; i++) {

a[i] = b[i] + 2;

}

int main(){

const int16_t size = 1024;

int16_t a[size], b[size];

addtwo(a, b, size);

return a[0];

}

迴圈迭代 1024 次，每次把兩個長度為 16 位元的有符號整型相加。使用向量操作的話，上例中的迴圈總數可減少到 128。但這也可能自動完成，在GCC環境中，可用 vector_size 定義向量資料型別，用這些資料和屬性顯式指導編譯器使用向量擴充套件操作。此處列舉出 emmintrin.h 定義的採用 SSE 指令集的多種向量資料型別。

/* SSE2 */
typedef double __v2df __attribute__ ((__vector_size__ (16)));
typedef long long __v2di __attribute__ ((__vector_size__ (16)));
typedef int __v4si __attribute__ ((__vector_size__ (16)));
typedef short __v8hi __attribute__ ((__vector_size__ (16)));
typedef char __v16qi __attribute__ ((__vector_size__ (16)));

/* SSE2 */

typedef double __v2df __attribute__ ((__vector_size__ (16)));

typedef long long __v2di __attribute__ ((__vector_size__ (16)));

typedef int __v4si __attribute__ ((__vector_size__ (16)));

typedef short __v8hi __attribute__ ((__vector_size__ (16)));

typedef char __v16qi __attribute__ ((__vector_size__ (16)));

這是用 __v8hi 型別優化之前的示例程式碼後的樣子：

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

static void __always_inline _addtwo(__v8hi *a, __v8hi *b, const int16_t sz){
    __v8hi c = {2,2,2,2,2,2,2,2};

    int16_t i;
    for (i = 0; i < sz; i++) {
        a[i] = b[i] + c;
    }
}

static void __always_inline addtwo(int16_t *a, int16_t *b, const int16_t sz){
    _addtwo((__v8hi *) a, (__v8hi *) b, sz/8);
}

int main(){
    const int16_t size = 1024;
    int16_t a[size], b[size];
    /* ... */

    addtwo(a, b, size);
    return a[0];
}

#include <stdint.h>

#include <string.h>

#include <emmintrin.h>

static void __always_inline _addtwo(__v8hi *a, __v8hi *b, const int16_t sz){

__v8hi c = {2,2,2,2,2,2,2,2};

int16_t i;

for (i = 0; i < sz; i++) {

a[i] = b[i] + c;

}

static void __always_inline addtwo(int16_t *a, int16_t *b, const int16_t sz){

_addtwo((__v8hi *) a, (__v8hi *) b, sz/8);

}

int main(){

const int16_t size = 1024;

int16_t a[size], b[size];

/* ... */

addtwo(a, b, size);

return a[0];

}

關鍵是把資料轉到合適的型別（此例中為 __v8hi），然後由此調整其他的程式碼。優化的效果主要看操作型別和處理資料量的大小，可能不同情況的結果差異很大。下表是上例中 addtwo 函式被迴圈呼叫 1 億次的執行時間：

Compiler	Time
gcc 4.5.4 O2	1m 5.3s
gcc 4.5.4 O2 auto vectorized	12.7s
gcc 4.5.4 O2 manual	8.9s
gcc 4.7.3 O2 auto vectorized	25.s
gcc 4.7.3 O2 manual	8.9s
clang 3.3 O3 auto vectorized	8.1s
clang 3.3 O3 manual	9.5s

Clang 編譯器自動向量化得更快，可能是因為用以測試的外部迴圈被優化的更好。慢一點的 GCC 4.7.3在記憶體對齊（見下文）方面效率稍低。

int32_t i;
for(i=0; i < 100000000; i++){
    addtwo(a, b, size);
}

int32_t i;

for(i=0; i < 100000000; i++){

addtwo(a, b, size);

}

6.1 使用內建函式（ Intrinsic Function）

GCC 和 Clang 編譯器也提供了內建函式，用來顯式地呼叫匯編指令。

確切的內建函式跟編譯器聯絡很大。x86 平臺下，GCC 和 Clang 編譯器都提供了帶有定義的標頭檔案，通過 x86intrin.h 匹配 Intel 編譯器的內建函式（即 GCC 和 Clang 用 Intel 提供的標頭檔案，呼叫 Intel 的內建函式。譯者注）。下表是含特殊指令集的標頭檔案：

MMX: mmintrin.h
SSE: xmmintrin.h
SSE2: emmintrin.h
SSE3: mm3dnow.h
3dnow: tmmintrin.h
AVX: immintrin.h

使用內建函式後，前面的例子可以改為：

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

static void __always_inline addtwo(int16_t *a, int16_t *b, int16_t size){

    int16_t i;
    __m128i c = _mm_set1_epi16(2);

    for (i = 0; i < size; i+=8) {
        __m128i bb = _mm_loadu_si128(b+i);  // movqdu b+i -> xmm0
        __m128i r = _mm_add_epi16(bb, c);   // paddw c + xmm0 -> xmm0
        _mm_storeu_si128(a+i, r);           // movqdu xmm0 -> a+i
    }
}

int main(){
    const int16_t size = 1024;
    int16_t a[size], b[size];
    /* ... */

    addtwo(a, b, size);
    return a[0];
}

#include <stdint.h>

#include <string.h>

#include <emmintrin.h>

static void __always_inline addtwo(int16_t *a, int16_t *b, int16_t size){

int16_t i;

__m128i c = _mm_set1_epi16(2);

for (i = 0; i < size; i+=8) {

__m128i bb = _mm_loadu_si128(b+i); // movqdu b+i -> xmm0

__m128i r = _mm_add_epi16(bb, c); // paddw c + xmm0 -> xmm0

_mm_storeu_si128(a+i, r); // movqdu xmm0 -> a+i

}

int main(){

const int16_t size = 1024;

int16_t a[size], b[size];

/* ... */

addtwo(a, b, size);

return a[0];

}

當編譯器產生次優的程式碼，或因程式碼中的 if 條件向量型別不可能表達需要的操作時時，可能需要這種編寫程式碼的方法。

6.2 記憶體對齊

注意到上個例子用了與 movqdu 而非 movqda （上面的例子裡僅用 SIMD 產生的彙編指令使用的是 movqda。譯者注）同義的 _mm_loadu_si128。這因為不確定 a 或 b 是否已按 16 位元組對齊。使用的指令是期望記憶體物件對齊的，但使用的記憶體物件是未對齊的，這樣肯定會導致執行錯誤或資料毀壞。為了讓記憶體物件對齊，可在定義時用 aligned 屬性指導編譯器對齊記憶體物件。某些情況下，可考慮把關鍵資料按 64 位元組對齊，因為 x86 L1 快取也是這個大小，這樣能提高快取使用率。

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

static void __always_inline addtwo(int16_t *a, int16_t *b, int16_t size){

    int16_t i;
    __m128i c = _mm_set1_epi16(2) __attribute__((aligned(16)));

    for (i = 0; i < size; i+=8) {
        __m128i bb = _mm_load_si128(b+i);  // movqda b+i -> xmm0
        __m128i r = _mm_add_epi16(bb, c);   // paddw c + xmm0 -> xmm0
        _mm_store_si128(a+i, r);           // movqda xmm0 -> a+i
    }
}

int main(){
    const int16_t size = 1024;
    int16_t a[size], b[size] __attribute__((aligned(16)));
    /* ... */

    addtwo(a, b, size);
    return a[0];
}

#include <stdint.h>

#include <string.h>

#include <emmintrin.h>

static void __always_inline addtwo(int16_t *a, int16_t *b, int16_t size){

int16_t i;

__m128i c = _mm_set1_epi16(2) __attribute__((aligned(16)));

for (i = 0; i < size; i+=8) {

__m128i bb = _mm_load_si128(b+i); // movqda b+i -> xmm0

__m128i r = _mm_add_epi16(bb, c); // paddw c + xmm0 -> xmm0

_mm_store_si128(a+i, r); // movqda xmm0 -> a+i

}

int main(){

const int16_t size = 1024;

int16_t a[size], b[size] __attribute__((aligned(16)));

/* ... */

addtwo(a, b, size);

return a[0];

}

考慮到程式執行速度，使用自動變數好過靜態或全域性變數，情況允許的話還應避免動態記憶體分配。當動態記憶體分配無法避免時，Posix 標準和 Windows 分別提供了 posix_memalign 和 _aligned_malloc 函式返回對齊的記憶體。

高效使用向量擴充套件喊程式碼優化需要深入理解目標架構工作原理和能加速程式碼執行的彙編指令。這兩個主題相關的資訊源有 Agner`s CPU blog 和它的裝訂版 Optimization manuals。

七、逸聞軼事

本文最後一節討論 C 程式語言裡一些有趣的地方：

array[i] == i[array];

1	array[i] == i[array];

因為下標操作符等價於*(array + i)，因此 array 和 i 是可交換的，二者等價。

$ gcc -dM -E - < /dev/null | grep -e linux -e unix
#define unix 1
#define linux 1

$ gcc -dM -E - < /dev/null | grep -e linux -e unix

#define unix 1

#define linux 1

預設情況下，GCC 把 linux 和 unix 都定義為 1，所以一旦把其中一個用作函式名，程式碼就會編不過。

int x = 'FOO!';
short y = 'BO';

1 2	int x = 'FOO!'; short y = 'BO';

沒錯，字元表示式可擴充套件到任意整型大小。

x = i+++k;
x = i++ +k;

1 2	x = i+++k; x = i++ +k;

字尾自增符在加號之前被詞法分析掃描到。

（即示例中兩句等價，不同於 x = i + (++k) 。譯者注）

x = i+++++k; //error
x = i++ ++ +k; //error

y = i++ + ++k; //ok

x = i+++++k; //error

x = i++ ++ +k; //error

y = i++ + ++k; //ok

詞法分析查詢可被處理的最長的非空格字元序列（C標準6.4節）。第一行將被解析成第二行的樣子，它們倆都會產生關於缺少左值的錯誤，缺失的左值本應該被第二個自增符處理。

致謝

若有需要增改之處，歡迎留言到原文連結。

參考文獻

C# 擴充套件方法借籤於 Objective-C 擴充套件類.
2010-12-08
C#套件Object
c# 高階應用理解擴充套件方法
2018-03-06
C#套件
C++ 對C的擴充套件有哪些
2024-10-03
C++套件
Kotlin 常見內聯擴充套件函式的使用
2017-12-22
Kotlin套件函式
C 擴充套件庫 – mysql API
2019-05-13
套件MySqlAPI
C#.NET擴充套件方法
2016-03-03
C#套件
C++對C語言的擴充套件(1)--引用
2021-01-05
C++C語言套件
gcc對C語言的擴充套件：語句內嵌表示式（statement-embeddedexpression）
2017-11-11
GCC語言套件Express
C#中的擴充套件類的理解
2018-10-05
C#套件
C-如何快速生成Python的C擴充套件.md
2022-01-09
Python套件
C#可擴充套件程式設計之MEF學習筆記(五)：MEF高階進階
2014-09-24
C#套件程式設計筆記
c盤擴充套件卷選項是灰的怎麼辦 c盤不能擴充套件卷的辦法
2021-10-23
套件
TLS擴充套件的那些事
2020-08-19
TLS套件
kotlin 擴充套件（擴充套件函式和擴充套件屬性）
2019-02-26
Kotlin套件函式
Flask-WTF進階和WTForms擴充套件
2016-03-03
FlaskORM套件
c# ExpandoObject動態擴充套件物件
2018-09-20
C#Object套件物件
gcc對C語言的擴充套件：語句內嵌表示式（statement-embedded expression）薦
2006-10-10
GCC語言套件Express
.NET: 談談C#中的擴充套件方法
2021-09-09
C#套件
Java 中模擬 C# 的擴充套件方法
2021-11-27
JavaC#套件
用C語言擴充套件Python的功能
2016-05-22
C語言套件Python
C#基礎系列：擴充套件方法的使用
2016-02-27
C#套件
Linux 核心使用的 GNU C 擴充套件(轉)
2007-08-11
Linux套件
【Kotlin】擴充套件屬性、擴充套件函式
2024-04-08
Kotlin套件函式
C到C++的擴充
2018-01-08
C++
擴充套件表示式
2021-09-09
套件
Kotlin委託 & 擴充套件 & 高階函式
2017-12-13
Kotlin套件函式
PostgreSql擴充套件Sql-動態載入共享庫(C函式)
2018-08-28
SQL套件函式
C# 2008 學習筆記 - 擴充套件函式
2013-12-25
C#筆記套件函式
C#學習筆記（補充）——擴充套件方法、事件
2019-02-16
C#筆記套件事件
C++11語言擴充套件：常規特性
2014-01-15
C++套件
Objective-C 類別(category)和擴充套件(Extension)
2013-09-25
ObjectGo套件
C#新特性：匿名類和擴充套件方法
2008-06-12
C#套件
linux下php實現C/C++擴充套件程式設計
2011-10-11
LinuxPHPC++套件程式設計
使用高階函式實現類的擴充套件設計
2015-12-21
函式套件
[譯]AppExtension程式設計指南:擴充套件基礎3
2018-11-19
APP程式設計套件
C++學習筆記-C++對C語言的函式擴充
2020-04-05
C++筆記C語言函式
使用Kotlin擴充套件函式擴充套件Spring Data案例
2021-11-11
Kotlin套件函式Spring
C#中的this擴充套件方法與javascript中的prototype方法
2009-02-11
C#套件JavaScript

C進階指南（3）：顯式內聯、向量擴充套件、C的逸聞軼事

五、顯式內聯

六、向量擴充套件

6.1 使用內建函式（ Intrinsic Function）

6.2 記憶體對齊

七、逸聞軼事

致謝

參考文獻

相關文章