此文已由作者餘笑天授權網易雲社群釋出。

歡迎訪問網易雲社群，瞭解更多網易技術產品運營經驗。

  本文主要是基於我之前學習《深入理解計算機系統》(以下簡稱CSAPP)這本書第五章優化程式效能內容的回顧以及總結。主要內容並沒有從大而全的方面去闡述如何優化程式，而是從一些細節著手來看待優化程式碼質量這個大問題。由於我之前接觸C/C++程式較多，因此示例程式碼都是用C++編寫，但是我認為無論是什麼語言，一些基本的優化原則是相通的。

 1.程式優化原則

    在CSAPP作者看來效能好的程式要有以下幾種特點：

    (1)合適的資料結構和演算法，都說程式=演算法+資料結構，因此這兩方面的優化是程式優化的基石。

    (2)儘量的寫出編譯器可以有效優化的程式碼，現代編譯器都會對原始碼進行優化，以提高程式的效能。比如Linux下的GCC編譯器就能控制優化的等級，優化等級高，對應的程式效能好。如果你的程式編譯器並不能確定是否能進行安全優化，那麼對於一些的成熟的編譯器而言，它並不會採用一些激進的優化方式，這部分內容在優化安全性會有具體介紹。

    (3)對於處理運算量特別大的計算，可以將一個任務拆分為多個任務。甚至可以考慮到在多核和對處理器上進行平行計算，這部分內容在CSAPP中的12章會有詳細敘述。

    (4)在實現和維護程式碼的簡單性和執行速度之間做出權衡，比如呼叫系統的排序演算法可以滿足日常大部分的排序需求，但是進行特殊的優化可能要針對排序的資料進行分析然後對應修改排序演算法，這個過程耗費的時間和最後的優化結果以及優化後可能帶來的可讀性、模組性的降低需要作出權衡。

    1.1優化的安全性

    對於C/C++程式，大多數的編譯器會指定優化級別，以GCC為例子：gcc -o指令就可以設定優化級別：

    -o0:關閉所有優化

    -o1:最基本的優化級別，編譯器試圖以較少的時間生成更快以及體積更小的程式碼。

    -o2:推薦的優化級別，o1的進階。

    -o3:較危險的優化等級，這個等級會延長編譯時間，編譯後會產生更大的二進位制檔案，會帶來一些無法預知的問題。

    -os:優化程式碼體積，通常適用於磁碟空間緊張或者CPU快取較小的機器。

     所謂優化的安全性，我們不妨看以下一個栗子：

可以看出看上去以上兩個函式實現的功能是一致的，都是將yp所指向的int值的兩倍加到xp所指向的值。但是f2的效能要比f1更好一些，因為f2有3次引用，f1有6次引用（2次讀xp，2次讀yp，2次寫xp）。我們期望編譯器會幫我們進行以上優化，但是成熟的編譯器不會這麼做的，這是因為該程式存在記憶體別名使用（memory aliasing）的問題。就是說xp，yp可能指向同一位置：

    可以看出當出現以上情況時，兩個函式的行為並不一致，這類程式的編寫就成為了編譯器優化它的阻礙因素，對應到優化原則的第二條。

    其次函式呼叫同樣會阻礙編譯器的優化，編譯器是不會對函式內容作出假設，因此針對函式呼叫，編譯器一般不會貿然進行優化，同樣可以舉出一個栗子：

    可以看出f1呼叫了f()兩次，而f2()只調用了一次，函式的呼叫涉及到棧幀的操作這需要消耗一些系統資源，因此按理來說f2()的效能優於f1()，但是編譯器針對這種情況同樣不會進行優化，考慮到以下程式碼：

    同樣可以看出在這種情況下，兩個函式行為同樣會不一致。

    2消除低效的迴圈

    我們編寫了一個迴圈累加的程式來測試在不同迴圈下，程式效能的開銷，首先定義了這樣一個數據結構：

typedef struct {	long int len;
	data_t *data;
}vec_rec, *vec_ptr;

   vec_rec表示為data_t的陣列，data_t表示為自定義的資料型別，len為該陣列的長度。

    原書中針對date_t進行了兩種定義分別是:整數以及浮點數，並對各自的型別進行加法和乘法的操作，分別統計各自的效能情況，於此同時還定義了效能衡量標準CPE即每元素時鐘週期，舉個栗子:計算一個數組中所有元素之和，分別統計陣列元素個數不同的情況下該程式所用的時鐘週期，然後得出每加入一個元素平均多耗費的時鐘週期，這個值就是CPE。下面是該書的作者統計的CPE值，這部分由於本人並沒有做實驗，因此只貼出作者的結果以供參考：

  可以看出目前的CPU對於浮點操作的優化使其效能接近甚至略好於對整數的操作，同時對於程式至少進行o1級別的優化同樣是有必要的。

    下面貼出具體的迴圈呼叫程式碼：

#include"stdlib.h"#include"time.h"#include#ifndef _CLOCK_T_DEFINED
#define _CLOCK_T_DEFINED
#endif
typedef long clock_t;
using namespace std;
typedef int data_t;
typedef struct 
{	long int len;
	data_t *data;
}vec_rec, *vec_ptr;vec_ptr new_vec(long len){
	vec_ptr res = (vec_ptr)malloc(sizeof(vec_rec));
	data_t *data = NULL;	if (!res)		return NULL;
	res->len = len;	if (len > 0)
	{
		data = (data_t *)calloc(len, sizeof(data_t));		if (!data)
		{
			free((void*)res);			return NULL;
		}
	}
	res->data = data;	return res;
}long vec_length(vec_ptr v){	return v->len;
}int get_vec_element(vec_ptr v,long index, data_t  *dest){	if (index < 0 || index >= v->len)		return 0;
	*dest = v->data[index];	return 1;
}void combine1(vec_ptr v, data_t  *dest) {	long i;
	*dest = 0;	for (i = 0; i < vec_length(v); ++i)
	{
		data_t val;
		get_vec_element(v, i, &val);
		*dest = *dest + val;
	}
}

    該程式分別依次取陣列元素的值然後加到dest所指的位置中去，這是一般的迴圈累加的寫法，可以看到每次迭代求值都會對測試條件進行求值操作，另一方面針對這種情況，陣列的長度並不會隨著迴圈而更改，因此我們定義了combine2如下：

void combine2(vec_ptr v, data_t  *dest){	long  i;	long len = vec_length(v);
	*dest = 0;	for (i = 0; i < len; ++i)
	{
		data_t val;
		get_vec_element(v, i, &val);
		*dest = *dest + val;
	}
}

    為了對比效能，我做了以下實驗：

int main()
{
	vec_ptr vec = new_vec(100000000);	int* tmp = new int[100000000];
	vec->data = (int *)tmp;	int res = 0;
	clock_t start, finish;	double totaltime;
	start = clock();
	combine1(vec, &res);
	finish = clock();
	totaltime = (double)(finish - start) / CLOCKS_PER_SEC;	cout << "\n此程式的執行時間為" << totaltime << "秒！" << endl;
	start = clock();
	combine2(vec, &res);
	finish = clock();
	totaltime = (double)(finish - start) / CLOCKS_PER_SEC;	cout << "\n此程式的執行時間為" << totaltime << "秒！" << endl;
	system("pause");
}

得到如下結果：

    3減少過程呼叫

    一個函式的呼叫基本過程大致如下：

    1、呼叫者函式把被調函式所需要的引數按照與被調函式的形參順序相反的順序壓入棧中

    2、呼叫者函式使用call指令呼叫被調函式,並把call指令的下一條指令的地址當成返回地址壓入棧中

    3、在被調函式中,被調函式會先儲存呼叫者函式的棧底地址(push ebp),然後再儲存呼叫者函式的棧頂地址

    4、在被調函式中,從ebp的位置處開始存放被調函式中的區域性變數和臨時變數,並且這些變數的地址按照定義時的順序依次減小

    可以看出在函式呼叫過程中，需要做一些壓棧出棧操作，同時需要一些暫存器幫助儲存和恢復環境，這些都將帶來系統開銷。因此減少一些函式呼叫將會提高程式效能。以上面的程式為例，可以看到combine函式在迴圈中呼叫了get_vec_element操作，這部分操作可以移到迴圈內部而不必呼叫函式，具體做法如下：

    增加get_vec_start函式獲取陣列起始位置：

data_t *get_vec_start(vec_ptr v)
{	return v->data;
}

  修改combine函式：

void combine3(vec_ptr v, data_t  *dest){	long  i;	long len = vec_length(v);
	data_t *data = get_vec_start(v);
	*dest = 0;	for (i = 0; i < len; ++i)
	{
		*dest = *dest + data[i];
	}
}

     修改後的程式效能對比如下：

  4消除不必要的引用

    combine3將計算後的值累加在dest指標後，一下貼出段程式碼的彙編結果：

  從這段程式碼可以看出dest指標放在暫存器rax中，每次迭代，data指標加1。每次迭代後。累積的數值從記憶體中讀出再寫入到記憶體中，這樣頻繁的讀寫記憶體將會影響程式的效能。

  這類頻繁的記憶體讀寫是可以避免的，可以引入一個臨時變數儲存*dest的值，迴圈中只取變數的值，直至迴圈結束將結果寫到dest指標所指的位置中。程式碼如下:

void combine4(vec_ptr v, data_t  *dest){	long  i;	long len = vec_length(v);
	data_t *data = get_vec_start(v);	long acc = 0;	//*dest = 0;
	for (i = 0; i < len; ++i)
	{
		acc = acc + data[i];
	}
	*dest = acc;
}

  這段程式碼的彙編結果如下：

   可以看出該部分彙編程式碼用rax儲存累計值沒有涉及到取記憶體的操作，因此在迴圈中的記憶體操作變成只有取data陣列這一次。

      以下貼出結果對比：

  可以看出combine4在之前的基礎上效能又稍有提高。

    5迴圈展開

    迴圈展開是一種程式變換，通過增加每次迴圈的計算量，減少迴圈次數從而改程序序效能。迴圈展開對程式效能的影響有兩點，其一是它減少了迴圈中的輔助計算量例如迴圈索引和條件分支（該書5.7節詳細介紹了條件分支對效能的影響）。第二它減少了關鍵路徑的運算元量。下面給出迴圈展開的一個版本：

void combine5(vec_ptr v, data_t  *dest){	long  i=0;	long len = vec_length(v);	long limit = len - 1;
	data_t *data = get_vec_start(v);
	data_t acc = 0;	for (int i = 0; i < limit; i += 3)
	{
		acc = (acc + data[i]) + data[i + 1];
	}        if (i < len)
	{
		acc = acc + data[i];
	}
	*dest = acc;
}

  下面是迴圈展開後的程式效能:

  該版本的迴圈展開將原有的迴圈次數減少了一半，延續這個思想，可將迴圈按任意因子k展開，下面是作者將改程式迴圈展開後多次後效能表現情況:

  可以看出對於該優化不會超過延遲界限值，檢視迴圈展開操作的彙編程式碼：

  可以看到該操作會導致兩條vmulsd操作，一條將data[i]加到acc上，第二條將data[i+1]加到acc上。每條vmulsd被翻譯成兩個操作：一個操作是從記憶體中載入一個數組元素，另一個是把這個值乘以已有的累計值。可以看到，迴圈的每次執行中，對暫存器%xmm0讀和寫兩次。從中可以看到，迭代的次數減半了，但是每次迭代中還是有兩個順序的乘法操作。這個關鍵路徑是迴圈沒有展開程式碼的效能制約因素。具體彙編程式碼過程圖示如下：

  至此，完成了該程式的初步優化，關於迴圈展開部分，該書第五章後半段有進階的內容，有興趣的同學可以一起學習交流。

更多網易技術、產品、運營經驗分享請點選。