匯編優化提示。本站提示廣大學習愛好者：（匯編優化提示）文章只能為提供參考，不一定能成為您想要的結果。以下是匯編優化提示正文
你需記住的最重要的事情就是代碼破費的時間！不同的辦法可以減速你的代碼或許不能，所以你要多多嘗試。因此計算代碼破費的時間來看看你嘗試的每個辦法能否可以提速是件很重要的事情。
；=========================初級=========================
<1>釋放一切8-CPU存放器，以使它們用於你自己的代碼中
push ebx
push esi
push edi
push ebp ；必需在改動ESP之前完成
；裝載ESI、EDI和其他傳遞棧中值的存放器，這必需在釋放ESP之前完成。
movd mm0,esp ； 沒有入棧/出棧操作超越此處，
xor ebx,ebx ； 所以你怎樣保管呢?一個變量嘛！
mov esp,5
inner_loop:
mov [eax_save],eax ； eax_save是一個全局變量不能夠是局
； 部的，由於那要求EBP來指向它。
add ebx,eax
mov eax,[eax_save] ； 存儲 eax
movd esp,mm0 ； 必需在做POPs之前完成
pop ebp
pop edi
pop esi
pop ebx
ret
<2>存放器的最大化運用
少數初級點的編譯器會發生十分多的到內存變量的訪問。我通常防止那樣做，由於我盡力把這些變量放在存放器中。所以要使8-CPU存放器自在運用，以備燃眉之急~
<3>復雜指令
防止復雜指令(lods, stos, movs, cmps, scas, loop, xadd, enter, leave)。復雜指令就是那些可以做許多事情的指令。例如，stosb向內存寫1字節，同時添加EDI。 這些復雜指令阻止晚期的Pentium疾速運轉，由於處置器的開展趨向是力使自己更像精簡指令集計算機(RISC)。運用rep和字符串指令照舊很快----而這是獨一的例外。
<4>不要再P4上運用INC/DEC
在P4上用ADD/SUB替代INC/DEC。通常前者更快些。ADD/SUB消耗0.5 cycle而INC/DEC消耗1 cycle.
<5>循環移位(rotating)
防止用存放器作循環移位計數器；立刻數作計數器時，除了1，不要用其他值。
<6>消弭不用要的比擬指令
經過合理運用條件跳轉指令來消弭不用要的比擬指令，但是，這些條件跳轉指令時基於標志位的。而這些標志位曾經被後面的算術指令設置了。
dec ecx
cmp ecx,0
jnz loop_again
優化為：
dec ecx
jnz loop_again
<7>lea指令的運用
lea十分酷，除了在P4上它表現得慢一點。你可以在這一條指令中執行許少數學運算，並且它不會影響標志存放器。所以你可以把它放在一個正在被修正的存放器和一個觸及標志位的條件跳轉指令兩頭。
top_of_loop:
dec eax
lea edx,[edx*4+3] ； 乘4加3。不影響標志位
jnz top_of_loop ； 所以jnz判別的是dec eax執行後的形態字
<8>ADC和SBB的運用
許多編譯器都不充沛應用ADC和SBB。你可以用它們很好地提速，如：把兩個64-bit的數加在一同或許兩個大數相加。記牢：ADC和SBB在P4上慢。當你手頭有相似任務時，你可以運用addq和用MMX來完成。所以第二個優化建議是：用MMX做這樣的加減法。但你的處置器必需支持MMX。
add eax,[fred]
adc edx,[fred+4]
；上面的3條指令完成異樣的功用
movd mm0,[fred] ；失掉MM0中的32-bit的值
movd mm1,[fred+4] ；失掉MM1中的32-bit的值
paddq mm0,mm1 這是一種未優化的辦法，實踐上，你可以在後面的循環中預取MM0和MM1。我這樣做是為了好了解。
<9>ROL, ROR, RCL, RCR 和 BSWAP
運用BSWAP指令把Big Endian數據轉換成Little Endian格式是很酷的一種辦法。你也可以運用它暫時存儲存放器的高位的的值(16-bit或8-bit)。相似地，你可以運用ROL/ROR來存儲8-bit或16-bit值。這也是取得更多“存放器”的一種辦法。假如你處置的都是16-bit的值，你可以把你的8個32-bit的存放器轉換成16個16-bit的存放器。這樣你就有更多存放器可以運用了。RCL和RCR可以很容易地被運用在計算存放器中比特位(0 or 1)的多少。牢記：P4上ROL, ROR, RCL, RCR 和 BSWAP速度慢。循環移位指令大約比BSWAP快2倍。所以，假如你必需在P4機上運用上述指令，還是選循環移位指令吧。
xor edx,edx ； 設置兩個16-bit的存放器為0
mov dx,234 ； 設置低位存放器為234
bswap edx ； 上下位存放器互換
mov dx,345 ； 設置以後低位存放器為345
bswap edx ； 以後上下位互換
add dx,5 ； 以後低位存放器加5
bswap edx ； 上下位互換
add dx,7 ； 以後低位存放器加7
<10>字符串指令
許多編譯器沒有充沛應用字符串指令( scas, cmps, stos, movs和 lods)。所以檢測這些指令寫成的函數能否比一些庫函數速度快是十分有意義的。例如：當我在看VC++的strlen()函數時，我真的很詫異。在radix40代碼中，處置一個100字節的字符串，它竟跑了416 cycles ！！！我以為這慢地荒謬！！！
<11>以乘代除
If you have a full 32-bit number and you need to divide, you can simply do a multiply
and take the top 32-bit half as the result. This is faster because multiplication is
faster than division. ( thanks to pdixon for the tip).
假如你有一個滿32-bit(full 32-bit)的數要做除法，你可以復雜地做乘法，然後取高32-bit局部作為後果。這樣會快些，由於乘法比除法快！(感激pdixon提供了這個tip)(譯者注：由於程度無限，此tip翻譯尚待商榷，而且不能給出一個例子。還仰仗各位幫助。)
<12>被常數除
這兒有一些很好的信息----怎樣被常數除(在Agner Fog的pentopt.pdf中)。我(Mark Larson)寫了一個小順序：可以依據你輸出的除數自動發生匯編代碼序列。我會持續探求探求，然後貼出來。這是Agner的文檔的鏈接。Agner's Pentopt PDF (http://www.agner.org/assem/)
<13>展開(Unrolling)
這是一個指點方針。在普通優化戰略裡，“展開”往往被疏忽，因而我想為它加個注腳。我總是用數值總數相等的宏來樹立我的“展開”構造。那樣的話，你可以嘗試不同的值來看看哪種是最容易的。你希望這個展開“安身”於L1代碼緩存(或追蹤緩存,trace cache)。運用等價(equate)語句可以很容易地嘗試不同的展開值來到達最快的速度。
UNROLL_AMT equ 16 ； # 展開循環的次數
UNROLL_NUM_BYTES equ 4 ； # 一次循環處置的字節數
mov ecx,1024
looper:
offset2 = 0
REPEAT UNROLL_AMT
add eax,[edi+offset2]
offset2 = offset2 + UNROLL_NUM_BYTES
add edi,UNROLL_AMT * UNROLL_NUM_BYTES ； 按16*4字節來處置
sub ecx,UNROLL_AMT ； 從循環計數器中減去展開循環的次數
jnz looper
<14>MOVZX指令
運用MOVZX來防止偏愛的存放器受阻。我運用MOVZX十分多。許多人首先將滿32-bit存放器(full 32-bit register)XOR一下。但是，MOVZX無需這個多余的XOR指令而可以完成異樣的事情。而且你必需提早做XOR運算，之後才干運用存放器，並且這個操作是破費一定時間的。但有MOVZX在，你就無需擔憂啦。
<15>用MOVZX來防止SHIFT和AND指令的運用
我用匯編來對C代碼中的位運算提速。the_array是一個dword的數組。代碼功用是失掉數組中一個dword的恣意字節。Pass是一個值為0-3的變量。因而這個功用有如下C代碼：
unsigned char c = ((the_array[i])>>(Pass<<3)) & 0xFF；
； 我為了防止Pass變量的運用，展開了循環4次。所以我失掉了如下更多的代碼：
unsigned char c = (the_array[i])>>0) & 0xFF；
unsigned char c = (the_array[i])>>8) & 0xFF；
unsigned char c = (the_array[i])>>16) & 0xFF；
unsigned char c = (the_array[i])>>24) & 0xFF；
在匯編中，我摒棄SHIFT和AND會發作什麼呢？浪費了我2個指令！更不必提P4上SHIFT指令十分慢(4 cycles!!!)的現實。所以假如能夠，盡量防止運用SHIFT指令。我們以第三行為例，所以只需右移16位即可：
mov eax,[esi] ； esi指向the_array數組
shr eax,16
and eax,0FFh
； 那麼我們怎樣防止SHR和AND的運用呢？我們舉例對dword中的第三個字節做MOVZX運算。
movzx eax,byte ptr [esi+2] ；unsigned char c = (the_array[i])>>16) & 0xFF；
<16>align指令
該偽指令十分重要，它可以對齊你的代碼和數據來很好地提速。對代碼，我通常按4字節邊界對齊。關於數據呢，2字節數據按2字節邊界對齊，4字節數據按4字節邊界對齊，8字節數據按8字節邊界對齊，16字節數據按16字節邊界對齊。普通狀況，假如不以一個16-bit邊界對齊SSE或SSE2數據的話，將會發生一個異常。假如有VC++開發包，你可以在VC++環境中對齊你的數據。VC++參加了對靜態數據和靜態內存的支持。關於靜態數據，你可以運用__declspec(align(4))來按4字節邊界對齊。
<17>用於2的冪的BSR指令
你可以把BSR命令用於變量的2的最高冪的計數。
<18>用XOR置存放器為0
這是十分陳腐的知識了，但是我仍然要重提一下。它也有一個正面益處----消弭對存放器的依賴性。這就是人們運用存放器之前用XOR置零成風的緣由。但我寧願運用MOVZX，由於XOR很狡詐~(看看我後面對MOVZX的討論)在P4上，也添加了PXOR支持，以消弭對XOR的依賴性。我以為P3做了異樣的事情。
<19>運用XOR和DIV
假如你確定你的數據在做除法時是無符號數，運用XOR EDX, EDX，然後DIV。它比CDQ和IDIV快。
<20>盡量防止分明的依賴關系
假如你修正一個存放器，然後在緊跟的下一行中讓它和某個值停止比擬，相反地，你最好在兩者之間拔出其他的存放器的修正指令。依賴就是任何時間你修正一個存放器，然後緊跟著對它讀或寫。(譯者注：其實就是AGI延遲； AGI: Address Generation Interlock)
inc edi
inc eax
cmp eax,1 ；這行依賴於上一行，所以發生延遲
jz fred
；挪動四周的指令到這兒可以打破這種依賴
inc eax
inc edi
cmp eax,1
jz fred
<21>P4機上防止運用的指令
在P4機上防止運用如下指令： adc, sbb, rotate指令, shift指令, inc, dec, lea, 和任何消耗多於 4 uops(微指令)的指令。你怎樣知道以後運轉代碼的處置器是P4？CPUID命令！
<22>運用查找表
在P4機上，你可以經過樹立查找表，來躲避長時間延遲的指令(後面已列出來)。幸而P4機的內存速度很快，所以假如樹立的查找表不在cache裡，它也並不會很大地影響功能。
<23>運用指針而不是計算下標(索引)
許多時分，C言語中的循環會呈現兩個非冪數的乘法。你可以很容易地用加法來完成。上面是一個運用構造體的例子：
typedef struct fred
{
int fred；
char bif；
}freddy_type；
freddy_type charmin[80]；
freddy_type構造的大小是5字節。假如你想在循環中訪問它們，編譯器會發生此種代碼----對每個數組元素的訪問都乘以5！！！Ewwwwwwwwwwwww(譯者注：語氣詞)！！！那麼我們應該怎樣做呢？
for ( int t = 0； t < 80； t++)
{
charmin[t].fred = rand()； // 編譯器為了失掉偏移量，竟乘以了5，EWWWWWWWW！
charmin[t].bif = (char)(rand() % 256)；
}
在匯編中，我們以偏移量0開端，這指向了數據第一個元素。然後我們每次把循環迭代器加5來防止MUL指令的運用。
mov esi,offset charmin
mov ecx,80
fred_loop:
；...freddy_type構造中FRED和BIF元素的處置命令
add esi,5 ；指向下一個構造的入口地址
dec ecx
jnz fred_loop
MUL指令的躲避也使用在循環中。我曾見過人們在循環中以乘來完成變量添加或許終止條件。相反，你應盡量用加法。
<24>服從默許分支預測
盡量設計你的代碼使向後的條件跳轉常常發作，並且向前的條件跳轉簡直從不發作。這顯然與分支預測有關。CPU中的靜態分支預測器(static branch predictor)只運用復雜的規則來猜想一個條件跳轉能否發作。所以應使向後跳轉的循環分支接近完畢。然後讓同一循環的特殊加入條件(exit condition)執行一個向前的跳轉(這個跳轉只在此跳轉不常常發作的這個特定的條件下加入)。
<25>消弭分支
假如能夠，消弭分支！這是顯然的，但我見過許多人在他們的匯編代碼中運用了太多的分支。堅持順序的復雜。運用盡能夠少的分支。
<26>運用CMOVcc來消弭分支
我曾見到過CMOVcc指令的確比條件跳轉指令快。所以我建議運用CMOVcc而非條件跳轉指令。當在你的跳轉不容易被分支預測邏輯猜到的狀況下，它能夠會更快。假如你遇到那種狀況，設定基准點(benchmark)看看！
<27>部分變量vs全局變量
在一個進程模塊(子函數)中運用部分變量而不是全局變量。假如你運用部分變量，你會失掉更少的緩存未命中(Cache miss)。
<28>地址計算
在你需求某地址之前計算它。不得不說你為了失掉某一特定地址必需計算一些令人厭惡的東西。例如地址乘20。你可以在需求該地址的代碼之前預算它。
<29>小點兒的存放器
有些時分，運用小點兒的存放器可以提升速度。我在radix40代碼中驗證了它。假如你運用EDX來修正上面的代碼，它跑得會慢些。
movzx edx,byte ptr [esi] ；從ascii數組取數據
test dl,ILLEGAL ；位測試
jnz skip_illegal
<30>指令長度
盡量使你的指令大小堅持在8字節以下。
<31>運用存放器傳遞參數
假如能夠，嘗試用存放器傳遞參數而不是棧。假如你有3個變量要壓棧作為參數，至多有6個內存讀操作和3個內存寫操作。你不得不把每個變量由內存讀入CPU存放器然後把它們壓入棧。這是3個內存讀操作。然後壓向棧頂發生3個寫操作。然後為什麼你會壓你從不運用的參數呢？所以，又呈現了最少3個讀棧操作。(譯者注：兩內存變量不能直接傳遞數據)
<32>不要向棧傳遞大數據
不要向棧傳遞64-bit或128-bit的數據(或許更大)。相反，你應該傳遞指向該數據的指針。
；=========================中級=========================
<33>加法方向
存放器加向內存比內存加向存放器速度更快。這與指令消耗的微指令(micro-ops)的多少有關。所以，你知道該怎樣做了。
add eax,[edi] ；假如能夠，不要這樣做
add [edi],eax ；這才是首選
<34>指令選擇
盡量選取發生最少微指令和最少延遲的指令。
<35>未對齊字節數據流的雙字(dword)對齊處置
關於沒有4字節邊界對齊的緩沖區，一次分解出一個dword會使功能埋沒。(譯者注：由於地址32-bit對齊時，處置速度最快)你可以經過處置開端的X(0-3)字節直到遇到一個4字節對齊的邊界處的辦法來躲避這種狀況。
<36>運用CMOVcc來復位一個有限循環指針
假如你想屢次傳遞一個數組，並當到達數組末端的時分復位到開端處，你可以運用CMOVcc指令。
dec ecx ； 增加數組索引
cmovz ecx,MAX_COUNT ； 假如在開端處，復位索引為 MAX_COUNT(開頭處)。
<37>以減法來替代乘以0.5的乘法
這能夠不會對一切狀況見效除了real4變量乘以0.5，或許被2除(real4變量是浮點數)，你只需把指數減1即可。但對0.0不見效。對real8變量，要減去00100000h。(這個tip是donkey貼出來的,donkey posted this)
.data
somefp real4 2.5
.code
sub dword ptr [somefp],00800000h ；用2除real4
<38>自修正代碼
P4優化手冊建議防止自修正代碼的運用。我已經見到過幾次自修正代碼可以跑得更快的狀況。但是每次運用前你都要明白它在以後狀況下會更快。(譯者注：自修正代碼即INC/DEC)
<39>MMX, SSE, SSE2指令
許多編譯器對MMX,SSE和SSE2不會發生很好的代碼。GCC和Intel編譯器對此做了更多任務，所以較其他產品好一些。但是你自己的"大腦+手"編譯器在這項任務中的使用依然是很大的成功。
<40>運用EMMS
EMMS在Intel處置器上傾向為很慢的指令。在AMD上它比擬快。通常我不會在例行的根底順序中運用它，由於它慢。我很少在有許多MMX指令的順序中再運用很多浮點指令。反之仍然(vice versa)。所以我常常在做任何浮點運算之前等著執行EMMS。假如你有許多浮點和很少的MMX，那麼應在你調用的一切的MMX子順序(假如有的話)執行完再執行EMMS。但是，在每個執行MMX的子順序中參加EMMS會使代碼變慢。
<41>轉換到MMX,SSE,SSE2
你的代碼能轉換到MMX, SSE, 或許SSE2嗎？假如能，你可以並行處置來極大的提升速度。
<42>預取數據
這往往未被充沛應用。假如你處置一個十分大的數組(256KB或更大)，在P3及當前處置器上運用PREFETCXH指令可以使你的代碼無論在什麼中央都可以提速10-30%。但現實上，假如你沒有合理運用的話，代碼功能還能夠升級。在這方面，“展開”表現良好，由於我把它展開為用此指令預取的字節的整數倍。在P3上，此倍數為32，而在P4上，它是128。這就意味著你可以在P4機上很容易地展開循環來一次處置128字節，你可以從預取和展開中失掉益處。但並不是在每種狀況下展開為128字節都會有最好的提速。你可以嘗試不同的字節數。
UNROLL_NUM_BYTES equ 4 ； 一次循環要處置的字節數
UNROLL_AMT equ 128/UNROLL_NUM_BYTES ；我們想展開循環以使它每次處置128字節
mov ecx,1024
looper:
offset2 = 0
REPEAT UNROLL_AMT
prefetchnta [edi+offset2+128] ； 在我們需求之前預取128字節到L1緩存
add eax,[edi+offset2]
offset2 = offset2 + UNROLL_NUM_BYTES
add edi,UNROLL_AMT * UNROLL_NUM_BYTES ； 我們處置16*4字節
sub ecx,UNROLL_AMT ； 調整迭代器到下一循環
jnz looper
<43>緩存模塊化(Cache Blocking)
不得不說，你必需對內存中的大數組調用許多進程(子函數)。你最好把數組分紅塊兒並裝入緩存(Cache)來增加緩存未命中(cache miss)。例如：你正在執行3D代碼，第一個進程能夠傳遞坐標，第二個進程能夠是規模大小，第三個能夠是變換方式。所以與其在整個的的大數組裡翻箱倒櫃似地找，你應該把數據大塊(chunk)分紅適於緩存(Cache)的小塊。然後調用此3個進程。然後停止上面數據大塊的相似操作。
<44>TLB啟動(TLB Priming)
TLB就是旁路轉換緩沖，或稱頁表緩沖(Translation Lookaside Buffer)，是虛擬內存地址到物理內存地址的轉換部件。它經過對頁表入口點的疾速訪問來提升功能。未在TLB緩存的代碼或數據會促使緩存未命中，這就降低了代碼速度。處理辦法就是：在你必需讀某頁之前預讀該頁的一個數據字節。我會在前面的tips中提供一個例子。
<45>混入代碼來消弭依賴
在C代碼中，C編譯器把不同的代碼塊辨別看待。當進入匯編言語級別時，你可以混入(intermix)它們來消弭依賴。
<46>並行處置
許多編譯器沒有充沛應用CPU有2個ALU流水線的現實，而ALU是人們運用的大局部。在P4機上你會更自得----假如操作妥當，你可以在一個指令周期執行4個ALU運算指令。假如你把義務分配，並行處置之，這也會消弭依賴。真是一箭雙雕！在循環中采取這個戰略。
looper:
mov eax,[esi]
xor eax,0E5h ；依賴上一行
add [edi],eax ；依賴上一行
add esi,4
add edi,4
dec ecx
jnz looper
；那麼我們如何使它並行化並且增加依賴呢？
looper:
mov eax,[esi]
mov ebx,[esi+4]
xor eax,0E5
xor ebx,0E5
add [edi],eax
add [edi+4],ebx
add esi,8
add edi,8
sub ecx,2
jnz looper
<47>防止內存訪問
重新構建代碼來防止內存訪問(或許其他I/O操作)。一種辦法就是在向內存寫一個值的時分，先在一個存放器中累加它。上面給出一個例子。在這個例子裡，假定每次循環我們從源數組向目的數組(元素為dword大小)延續相加3個字節的值。目的數組曾經置0。
mov ecx,AMT_TO_LOOP
looper:
movzx byte ptr eax,[esi]
add [edi],eax
movzx byte ptr eax,[esi+1]
add [edi],eax
movzx byte ptr eax,[esi+3]
add [edi],eax
add edi,4
add esi,3
dec ecx
jnz looper
；我們可以在存放器中累加後果，然後只需向內存寫一下即可。
mov ecx,AMT_TO_LOOP
looper:
xor edx,edx ；置0以存儲後果
movzx byte ptr eax,[esi]
add edx,eax
movzx byte ptr eax,[esi+1]
add edx,eax
movzx byte ptr eax,[esi+3]
add edx,eax
add esi,3
mov [edi],edx
add edi,4
dec ecx
jnz looper
<48>何時轉換call為jump
假如子順序的最後一個語句是一個call，思索把它轉換為一個jump來增加一個call/ret。
<49>運用數組作為數據構造
(這個tip不是只針對匯編的，但匯編表現更優良)你可以運用一個數組來完成數據的構造(例如樹和鏈表)。經過運用數組，內存會無縫銜接，代碼會因更少的緩存未命中而提速。
；=========================初級=========================
<50>防止前綴
盡量防止運用前綴。段逾越(segment overrides),分支標志(branch hints),操作數大小強迫轉換(operand-size override),地址大小強迫轉換(address-size override),封鎖數據指令(LOCKs),反復前綴(REPs)等都會發生前綴。前綴會添加指令的長度，執行時間也有所延伸。
<51>將代碼中的讀/寫操作分組
假如bus總線上有許多交互的讀命令和寫命令，思索分組。同一時間處置更多的讀和寫命令。上面的是我們要防止的：
mov eax,[esi]
mov [edi],eax
mov eax,[esi+4]
mov [edi+4],eax
mov eax,[esi+8]
mov [edi+8],eax
mov eax,[esi+12]
mov [edi+12],eax
；將讀和寫指令分組
mov eax,[esi]
mov ebx,[esi+4]
mov ecx,[esi+8]
mov edx,[esi+12]
mov [edi],eax
mov [edi+4],ebx
mov [edi+8],ecx
mov [edi+12],edx
<52>充沛應用CPU執行單元(EU,execution units)來減速代碼
選擇在不同處置單元執行的命令。假如你能合理地這樣做的話，執行代碼的時間會等於吞吐時間(throughput time)而沒有延遲時間(latency time)。對許多指令來說，吞吐時間是較少的。
<53>交織2個循環以同步執行
你可以展開一個循環2次，而不是一條接另一條的運轉命令，你可以同步運轉它們。這為什麼很有用？有2個緣由。第一，有時你要執行必需運用某個存放器的指令並且這些指令有很長的延遲。例如MUL/DIV，兩個連在一同的MUL指令會發生對EDX:EAX的依賴和爭用。第二，有時一些指令自身就有很長的延遲。所以，你自然想嘗試在在一個循環前面放置一些來自另一個循環的指令來增加延遲直到它前往後果。P4機上的許多MMX, SSE和SSE2指令都采取這個戰略。這兒有一個例子循環。
loop:
A1 ； instruction 1 loop 1
D2 ； instruction 4 loop 2
B1 ； instruction 2 loop 1
A2 ； instruction 1 loop 2
C1 ； instruction 3 loop 1
B2 ； instruction 2 loop 2
D1 ； instruction 4 loop 1
C2 ； instruction 3
loop 2
<54>運用MMX/SSE/SSE2時比擬指令設置的標志
當與MMX/SSE/SSE2打交道時，比擬指令會發生對標志位的設置。在某些狀況下，當你搜索一個文件中的形式(例如換行符)時，這會很有用。所以你可以運用它來搜索形式，而不只僅來做數學運算。你可以運用MMX/SSE/SSE2中比擬指令發生的標志來控制局部MMX或SSE存放器上的數學運算。例如上面的代碼片段：假如有5，把9加到它MMX存放器的dword局部。
； if (fredvariable == 5)
； fredvariable += 9；
；-------------------------------
movq mm5,[two_fives] ；mm5有兩個DWORD 5在外面
movq mm6,[two_nines] ；mm6有兩個DWORD 9在外面
movq mm0,[array_in_memory] ；取值
movq mm1,mm0 ；回寫
pcmpeqd mm1,mm5 ；mm1如今在每個DWORD地位都為FFFFFFFF
；在MM1有一個5，其他一切地位都為0
pand mm1,mm6 ；把MM6中不為5的地位置0
paddd mm0,mm1 ；只向MM0中值為5的地位加9
<55>PSHUFD和PUSHFW指令
在P4的MMX,SSE和SSE2中，挪動指令(MOV系列)速度慢。你可以在SSE和SSE2中運用"pushfd"，MMX中運用"pushfw"來防止如下情況。它快2指令周期呢。但有一個正告：它是與微指令被分配加載到哪個流水線有關的。而沒有掌握更多技術的時分，有時運用慢點的"MOVDQA"會比替代它的"PUSHFD"快。所以你要對你的代碼一絲不苟。
pushfd xmm0,[edi],0E4h ；拷貝EDI指向地位的16字節到XMM0。0E4h會直接拷貝。
pushfw mm0,[edi],0E4h ；拷貝EDI指向地位的8字節到MM0。0E4h會直接拷貝。
<56>直接寫內存---繞開緩存(cache)
這是另一個優化內存處置的戰略。假如你必需向許多內存空間(256KB及以上)停止寫操作，繞開緩存直接向內存寫更快！假如你的CPU是P3，你可以運用"movntq"或"movntps"指令。前者執行8字節的寫操作，然後者是16字節。16-byte寫需求16字節對齊。在P4上，你還可以運用"movntdq"，它也可以用於16字節，但必需16字節對齊。這個辦法在內存填充和內存拷貝中均適用，二者都做寫操作。這裡有一些樣本代碼。我必需自己入手並行運用8個XMM存放器來協助消弭P4機MOVDQA指令的一些延遲。但是，為了協助了解，我沒那麼做。
mov ecx,16384 ；寫16384個16-bit值，16384*16 = 256KB
；所以我們正在拷貝一個256KB的數組
mov esi,offset src_arr ；指向必需以16-bit對齊的源數組的指針，否則會發生異常
mov edi,offset dst_arr ；指向必需以16-bit對齊的目的數組的指針，否則會發生異常
looper:
movdqa xmm0,[esi] ；任務在P3及以上
movntps [edi],xmm0 ；任務在P3及以上
add esi,16
add edi,16
dec ecx
jnz looper
<57>運用MMX/SSE/SSE2時每個循環處置2個事情
在P4上，MMS/SSE/SSE2指令的延遲那麼長以致於我總是每個循環處置2個事情或許提早讀取一個循環。假如你有足夠的存放器，可以多於2個事情。一切的各種各樣的MOVE(包括MOVD)指令在P4上的速度都慢。所以2個32-bit的數字數組相加運算在P4上比P3上還慢。一個快點兒的辦法能夠就是每個循環(這個循環在FRED標號之前預讀循環初始值MM0和MM1)處置兩個事情。你必需做的只是在數組元素個數為奇時停止特殊的處置；在最後反省一下，假如為奇數，加一個額定的dword。這兒有個並沒有提早讀取值的代碼段。我想，把它改為提早讀取值是很容易的，所以我沒有兩個都貼出。上面的代碼可以：在P4機上防止ADC這個速度慢的指令來把兩個數組相加。
pxor mm7,mm7 ； the previous loops carry stays in here
fred:
movd mm0,[esi] ； esi points to src1
movd mm1,[edi] ； edi points to src2, also to be used as the destination
paddq mm0,mm1 ； add both values together
paddq mm0,mm7 ； add in remainder from last add
movd [edi],mm0 ； save value to memory
movq mm7,mm0
psrlq mm7,32 ； shift the carry over to bit 0
add esi,8
add edi,8
sub ecx,1
jnz fred
movd [edi],mm7 ； save carry
<58>預讀MMX或XMM存放器來躲避長時間的延遲
在需求之前預讀一個SSE2存放器會提升速度。這是由於MOVDQA指令在P4上破費6 cycles。這的確慢。鑒於它有如此長之延遲，我想在確定不會發生障礙的中央提早讀取它。這裡有一個例子。
movdqa xmm1,[edi+16] ；在我們需求之前讀取入XMM1，P4上破費6 cycles，不包括從緩存取的時間。
por xmm5,xmm0 ；做OR運算，XMM0已預讀。P4上破費2 cycles。
pand xmm6,xmm0 ；做AND運算，XMM0已預讀。P4上破費2 cycles。
movdqa xmm2,[edi+32] ；在我們需求之前預讀入XMM2，P4上破費6 cycles，不包括從緩存取的時間。
por xmm5,xmm1 ；做OR運算，XMM1已預讀。P4上破費2 cycles。
pand xmm6,xmm1 ；做AND運算，XMM1已預讀。P4上破費2 cycles。
<59>在一個或多個存放器中累加一個後果來防止執行慢的指令
在一個或多個存放器中累加一個後果來防止執行慢的指令。我用這個戰略減速用SSE2寫的比擬/讀循環。比擬慢的指令是PMOVMSKB。所以，我累加後果在一個存放器中而不是每次循環都執行這個指令。對每個4KB的內存讀操作，我會用PMOVMSKB，它會很大地提速。上面我們經過剖析一個運用PREFETCH和TLB啟動的例子來證明。上面的代碼有2個循環。內層循環被展開來處置128字節(P4機上PREFETCH指令的預取字節數)。另一個循環被展開為4KB。所以我可以運用TLB啟動。假如你運用的零碎沒有運用4KB頁大小，你不得不適外地修正你的代碼。在擁有最大6.4 GB/s內存帶寬的戴爾服務器(Dell Server)零碎上，我測試了這段代碼。我可以以5.55 GB/s做讀和比擬操作(在沒有Windows環境下。在Windows環境下會運轉地慢點)。我脫漏標號"compare_failed"的代碼有2個緣由：1)剪切/粘貼的代碼曾經夠多了；2)它沒有論證任何我要展示的技術。"compare_failed"的代碼只是復雜地(在PCMPEQD找到失敗地址所屬的最近的4KB內存塊後)做一個REP SCASD來找到失敗的地址。這個例子有十分宏大的代碼量，所以我把它放在最後以免你讀它的時分睡著；)(譯者注：覺得上面的代碼正文翻譯出來有點別扭，而且原文也不難了解。故略。)
read_compare_pattern_sse2 proc near
mov edi,[start_addr] ；Starting Address
mov ecx,[stop_addr] ；Last addr to NOT test.
mov ebx,0FFFFFFFFh ；AND mask
movd xmm6,ebx ；AND mask
pshufd xmm6,xmm6,00000000b ；AND mask
movdqa xmm0,[edi] ；Get first 16 bytes
mov eax,[pattern] ；EAX holds pattern
pxor xmm5,xmm5 ；OR mask
movd xmm7,eax ；Copy EAX to XMM7
pshufd xmm7,xmm7,00000000b ；Blast to all DWORDS
outer_loop:
mov ebx,32 ；128 32 byte blocks
mov esi,edi ；save start of block
if DO_TLB_PRIMING
mov eax,[edi+4096] ；TLB priming
endif ；if DO_TLB_PRIMING
fred_loop:
movdqa xmm1,[edi+16] ；read 16 bytes
por xmm5,xmm0 ；OR into mask
pand xmm6,xmm0 ；AND into mask
movdqa xmm2,[edi+32] ；read 16 bytes
por xmm5,xmm1 ；OR into mask
pand xmm6,xmm1 ；AND into mask
movdqa xmm3,[edi+48] ；read 16 bytes
por xmm5,xmm2 ；OR into mask
pand xmm6,xmm2 ；AND into mask
movdqa xmm0,[edi+64] ；read 16 bytes
por xmm5,xmm3 ；OR into mask
pand xmm6,xmm3 ；AND into mask
movdqa xmm1,[edi+80] ；read 16 bytes
por xmm5,xmm0 ；OR into mask
pand xmm6,xmm0 ；AND into mask
movdqa xmm2,[edi+96] ；read 16 bytes
por xmm5,xmm1 ；OR into mask
pand xmm6,xmm1 ；AND into mask
movdqa xmm3,[edi+112] ；read 16 bytes
por xmm5,xmm2 ；OR into mask
pand xmm6,xmm2 ；AND into mask
por xmm5,xmm3 ；OR into mask
prefetchnta [edi+928] ；Prefetch 928 ahead
pand xmm6,xmm3 ；AND into mask
add edi,128 ；Go next 128byteblock
cmp edi,ecx ；At end?
jae do_compare ；No, jump
movdqa xmm0,[edi] ；read 16 bytes
sub ebx,1 ；Incr for inner loop
jnz fred_loop
do_compare:
pcmpeqd xmm5,xmm7 ；Equal?
pmovmskb eax,xmm5 ；Grab high bits in EAX
cmp eax,0FFFFh ；all set?
jne compare_failed ；No, exit failure
mov edx,0FFFFFFFFh ；AND mask
pxor xmm5,xmm5
pcmpeqd xmm6,xmm7 ；Equal?
pmovmskb eax,xmm6 ；Grab high bits in EAX
cmp eax,0FFFFh ；All Set?
jne compare_failed ；No, exit failure
movd xmm6,edx ；AND mask
pshufd xmm6,xmm6,00000000b ；AND mask
cmp edi,ecx ；We at end of range
jb outer_loop ；No, loop back up
jmp compare_passed ；Done!!! Success!!!
<60>在循環內預取間隔和地位
你會留意到，在下面的例子中，我之前預取了928字節而不是128字節(128是P4機上的預取字節數)。為什麼？Intel建議在循環開端前預取128字節(2 cache lines)。但兩種不同取法(在循環開端處或提早預取128字節)都會出錯。我既沒有在循環開端時預取也沒之前預取128字節。為什麼？當我研討這段代碼時，我發現把PREFETCH指令放到循環四周並且改動它預取的偏移量可以使它運轉得更快。所以失常得是，我寫代碼來嘗試一切的循環內預取指令的地位和開端預取的偏移量的組合狀況。這段代碼寫成一個匯編文件，而且把四周的PREFETCH指令移到循環內，同時修正開端預取的偏移量。然後一個bat文件編譯這個修正的代碼並且運轉一個基准點(benchmark)。我運轉了這個基准點幾個小時來嘗試不同的組合狀況(我在預取間隔為32時開端，逐漸添加間隔直到間隔到達1024)。在此零碎上，我寫的基於928字節而不是128字節的代碼執行地更快。並且，簡直在循環完畢處預取是最快的(在do_compare標號之前，PREFETCHNTA指令大約8條line)。
THE END.
txt打包下載 huibianyouhuats_jb51
