為什么Julia比Python快？因為天生理念就更先進啊
其實像以前 C 或其它主流語言在使用變量前先要聲明變量的具體類型，而 Python 并不需要，賦值什么數(shù)據(jù)，變量就是什么類型。然而沒想到正是這種類型穩(wěn)定性，讓 Julia 相比 Python 有更好的性能。
選擇 Julia 的最主要原因：要比其他腳本語言快得多，讓你擁有 Python/Matlab /R 一樣快速的開發(fā)速度，同時像 C/Fortan 那樣高效的運行速度。
Julia 的新手可能對下面這些描述略為謹慎：
- 為什么其他語言不能更快一點?Julia 能夠做到，其他語言就不能?
- 你怎么解釋 Julia 的速度基準?(對許多其他語言來說也很難?)
- 這聽起來違背沒有免費午餐定律，在其他方面是否有損失?
許多人認為 Julia 快是因為它使用的是 JIT 編譯器，即每一條語句在使用前都先使用編譯函數(shù)進行編譯，不論是預先馬上編譯或之前先緩存編譯。這就產(chǎn)生了一個問題，即 Python/R 和 MATLAB 等腳本語言同樣可以使用 JIT 編譯器，這些編譯器的優(yōu)化時間甚至比 Julia 語言都要久。所以為什么我們會瘋狂相信 Julia 語言短時間的優(yōu)化就要超過其它腳本語言?這是一種對 Julia 語言的完全誤解。
在本文中，我們將了解到 Julia 快是因為它的設計決策。它的核心設計決策：通過多重分派的類型穩(wěn)定性是允許 Julia 能快速編譯并高效運行的核心，本文后面會具體解釋為什么它是快的原因。此外，這一核心決策同時還能像腳本語言那樣令語法非常簡潔，這兩者相加可以得到非常明顯的性能增益。
但是，在本文中我們能看到的是 Julia 不總像其他腳本語言，我們需要明白 Julia 語言因為這個核心決策而有一些「損失」。理解這種設計決策如何影響你的編程方式，對你生成 Julia 代碼而言非常重要。
為了看見其中的不同，我們可以先簡單地看看數(shù)學運算案例。
Julia 中的數(shù)學運算
總而言之，Julia 中的數(shù)學運算看起來和其他腳本語言是一樣的。值得注意的一個細節(jié)是 Julia 的數(shù)值是「真數(shù)值」，在 Float64 中真的就和一個 64 位的浮點數(shù)值一樣，或者是 C 語言的「雙精度浮點數(shù)」。一個 Vector{Float64} 中的內(nèi)存排列等同于 C 語言雙精度浮點數(shù)數(shù)組，這都使得它與 C 語言的交互操作變得簡單(確實，某種意義上 Julia 是構建在 C 語言頂層的)，且能帶來高性能(對 NumPy 數(shù)組來說也是如此)。
Julia 中的一些數(shù)學：
- a = 2+2
- b = a/3
- c = a÷3 #\div tab completion, means integer division
- d = 4*5
- println([a;b;c;d])
output: [4.0, 1.33333, 1.0, 20.0]
此外，數(shù)值乘法在后面跟隨著變量的情況下允許不使用運算符 *，例如以下的計算可通過 Julia 代碼完成：
- α = 0.5
- ∇f(u) = α*u; ∇f(2)
- sin(2π)
output: -2.4492935982947064e-16
類型穩(wěn)定和代碼自省
類型穩(wěn)定，即從一種方法中只能輸出一種類型。例如，從 *(:: Float64，:: Float64) 輸出的合理類型是 Float64。無論你給它的是什么，它都會反饋一個 Float64。這里是一種多重分派(Multiple-Dispatch)機制：運算符 * 根據(jù)它看到的類型調(diào)用不同的方法。當它看到 floats 時，它會反饋 floats。Julia 提供代碼自省(code introspection)宏，以便你可以看到代碼實際編譯的內(nèi)容。因此 Julia 不僅僅是一種腳本語言，它更是一種可以讓你處理匯編的腳本語言!與許多語言一樣，Julia 編譯為 LLVM(LLVM 是一種可移植的匯編語言)。
- @code_llvm 2*5
- ; Function *
- ; Location: int.jl:54
- define i64 @"julia_*_33751"(i64, i64) {
- top:
- %2 = mul i64 %1, %0
- ret i64 %2
- }
這個輸出表示，執(zhí)行浮點乘法運算并返回答案。我們甚至可以看一下匯編：
- @code_llvm 2*5
- .text
- ; Function * {
- ; Location: int.jl:54
- imulq %rsi, %rdi
- movq %rdi, %rax
- retq
- nopl (%rax,%rax)
- ;}
這表示*函數(shù)已編譯為與 C / Fortran 中完全相同的操作，這意味著它實現(xiàn)了相同的性能(即使它是在 Julia 中定義的)。因此，不僅可以「接近」C 語言的性能，而且實際上可以獲得相同的 C 代碼。那么在什么情況下會發(fā)生這種事情呢?
關于 Julia 的有趣之處在于，我們需要知道什么情況下代碼不能編譯成與 C / Fortran 一樣高效的運算?這里的關鍵是類型穩(wěn)定性。如果函數(shù)是類型穩(wěn)定的，那么編譯器可以知道函數(shù)中所有節(jié)點的類型，并巧妙地將其優(yōu)化為與 C / Fortran 相同的程序集。如果它不是類型穩(wěn)定的，Julia 必須添加昂貴的「boxing」以確保在操作之前找到或者已明確知道的類型。
這是 Julia 和其他腳本語言之間最為關鍵的不同點!
好處是 Julia 的函數(shù)在類型穩(wěn)定時基本上和 C / Fortran 函數(shù)一樣。因此^(取冪)很快，但既然 ^(:: Int64，:: Int64)是類型穩(wěn)定的，那么它應輸出什么類型?
- 2^5
output: 32
- 2^-5
output: 0.03125
這里我們得到一個錯誤。編譯器為了保證 ^ 返回一個 Int64，必須拋出一個錯誤。如果在 MATLAB，Python 或 R 中執(zhí)行這個操作，則不會拋出錯誤，這是因為那些語言沒有圍繞類型穩(wěn)定性構建整個語言。
當我們沒有類型穩(wěn)定性時會發(fā)生什么呢?我們來看看這段代碼：
- @code_native ^(2,5)
- .text
- ; Function ^ {
- ; Location: intfuncs.jl:220
- pushq %rax
- movabsq $power_by_squaring, %rax
- callq *%rax
- popq %rcx
- retq
- nop
- ;}
現(xiàn)在讓我們定義對整數(shù)的取冪，讓它像其他腳本語言中看到的那樣「安全」：
- function expo(x,y)
- if y>0
- return x^y
- else
- x = convert(Float64,x)
- return x^y
- end
- end
output: expo (generic function with 1 method)
確保它有效：
- println(expo(2,5))
- expo(2,-5)
output: 32
0.03125
當我們檢查這段代碼時會發(fā)生什么?
- @code_native expo(2,5)
- .text
- ; Function expo {
- ; Location: In[8]:2
- pushq %rbx
- movq %rdi, %rbx
- ; Function >; {
- ; Location: operators.jl:286
- ; Function <; {
- ; Location: int.jl:49
- testq %rdx, %rdx
- ;}}
- jle L36
- ; Location: In[8]:3
- ; Function ^; {
- ; Location: intfuncs.jl:220
- movabsq $power_by_squaring, %rax
- movq %rsi, %rdi
- movq %rdx, %rsi
- callq *%rax
- ;}
- movq %rax, (%rbx)
- movb $2, %dl
- xorl %eax, %eax
- popq %rbx
- retq
- ; Location: In[8]:5
- ; Function convert; {
- ; Location: number.jl:7
- ; Function Type; {
- ; Location: float.jl:60
- L36:
- vcvtsi2sdq %rsi, %xmm0, %xmm0
- ;}}
- ; Location: In[8]:6
- ; Function ^; {
- ; Location: math.jl:780
- ; Function Type; {
- ; Location: float.jl:60
- vcvtsi2sdq %rdx, %xmm1, %xmm1
- movabsq $__pow, %rax
- ;}
- callq *%rax
- ;}
- vmovsd %xmm0, (%rbx)
- movb $1, %dl
- xorl %eax, %eax
- ; Location: In[8]:3
- popq %rbx
- retq
- nopw %cs:(%rax,%rax)
- ;}
這個演示非常直觀地說明了為什么 Julia 使用類型推斷來實現(xiàn)能夠比其他腳本語言有更高的性能。
核心觀念：多重分派+類型穩(wěn)定性 => 速度+可讀性
類型穩(wěn)定性(Type stability)是將 Julia 語言與其他腳本語言區(qū)分開的一個重要特征。實際上，Julia 的核心觀念如下所示：
(引用)多重分派(Multiple dispatch)允許語言將函數(shù)調(diào)用分派到類型穩(wěn)定的函數(shù)。
這就是 Julia 語言所有特性的出發(fā)點，所以我們需要花些時間深入研究它。如果函數(shù)內(nèi)部存在類型穩(wěn)定性，即函數(shù)內(nèi)的任何函數(shù)調(diào)用也是類型穩(wěn)定的，那么編譯器在每一步都能知道變量的類型。因為此時代碼和 C/Fortran 代碼基本相同，所以編譯器可以使用全部的優(yōu)化方法編譯函數(shù)。
我們可以通過案例解釋多重分派，如果乘法運算符 * 為類型穩(wěn)定的函數(shù)：它因輸入表示的不同而不同。但是如果編譯器在調(diào)用 * 之前知道 a 和 b 的類型，那么它就知道哪一個 * 方法可以使用，因此編譯器也知道 c=a * b 的輸出類型。因此如果沿著不同的運算傳播類型信息，那么 Julia 將知道整個過程的類型，同時也允許實現(xiàn)完全的優(yōu)化。多重分派允許每一次使用 * 時都表示正確的類型，也神奇地允許所有優(yōu)化。
我們可以從中學習到很多東西。首先為了達到這種程度的運行優(yōu)化，我們必須擁有類型穩(wěn)定性。這并不是大多數(shù)編程語言標準庫所擁有的特性，只不過是令用戶體驗更容易而需要做的選擇。其次，函數(shù)的類型需要多重分派才能實現(xiàn)專有化，這樣才能允許腳本語言變得「變得更明確，而不僅更易讀」。***，我們還需要一個魯棒性的類型系統(tǒng)。為了構建類型不穩(wěn)定的指數(shù)函數(shù)(可能用得上)，我們也需要轉化器這樣的函數(shù)。
因此編程語言必須設計為具有多重分派的類型穩(wěn)定性語言，并且還需要以魯棒性類型系統(tǒng)為中心，以便在保持腳本語言的句法和易于使用的特性下實現(xiàn)底層語言的性能。我們可以在 Python 中嵌入 JIT，但如果需要嵌入到 Julia，我們需要真的把它成設計為 Julia 的一部分。
Julia 基準
Julia 網(wǎng)站上的 Julia 基準能測試編程語言的不同模塊，從而希望獲取更快的速度。這并不意味著 Julia 基準會測試最快的實現(xiàn)，這也是我們對其主要的誤解。其它編程語言也有相同的方式：測試編程語言的基本模塊，并看看它們到底有多快。
Julia 語言是建立在類型穩(wěn)定函數(shù)的多重分派機制上的。因此即使是最初版的 Julia 也能讓編譯器快速優(yōu)化到 C/Fortran 語言的性能。很明顯，基本大多數(shù)案例下 Julia 的性能都非常接近 C。但還有少量細節(jié)實際上并不能達到 C 語言的性能，首先是斐波那契數(shù)列問題，Julia 需要的時間是 C 的 2.11 倍。這主要是因為遞歸測試，Julia 并沒有完全優(yōu)化遞歸運算，不過它在這個問題上仍然做得非常好。
用于這類遞歸問題的最快優(yōu)化方法是 Tail-Call Optimization，Julia 語言可以隨時添加這類優(yōu)化。但是 Julia 因為一些原因并沒有添加，主要是：任何需要使用 Tail-Call Optimization 的案例同時也可以使用循環(huán)語句。但是循環(huán)對于優(yōu)化顯得更加魯棒，因為有很多遞歸都不能使用 Tail-Call 優(yōu)化，因此 Julia 還是建議使用循環(huán)而不是使用不太穩(wěn)定的 TCO。
Julia 還有一些案例并不能做得很好，例如 the rand_mat_stat 和 parse_int 測試。然而，這些很大程度上都歸因于一種名為邊界檢測(bounds checking)的特征。在大多數(shù)腳本語言中，如果我們對數(shù)組的索引超過了索引邊界，那么程序將報錯。Julia 語言默認會完成以下操作：
- function test1()
- a = zeros(3)
- for i=1:4
- a[i] = i
- end
- end
- test1()
- BoundsError: attempt to access 3-element Array{Float64,1} at index [4]
- Stacktrace:
- [1] setindex! at ./array.jl:769 [inlined]
- [2] test1() at ./In[11]:4
- [3] top-level scope at In[11]:7
然而，Julia 語言允許我們使用 @inbounds 宏關閉邊界檢測：
- function test2()
- a = zeros(3)
- @inbounds for i=1:4
- a[i] = i
- end
- end
- test2()
這會為我們帶來和 C/Fortran 相同的不安全行為，但是也能帶來相同的速度。如果我們將關閉邊界檢測的代碼用于基準測試，我們能獲得與 C 語言相似的速度。這是 Julia 語言另一個比較有趣的特征：它默認情況下允許和其它腳本語言一樣獲得安全性，但是在特定情況下(測試和 Debug 后)關閉這些特征可以獲得完全的性能。
核心概念的小擴展：嚴格類型形式
類型穩(wěn)定性并不是唯一必須的，我們還需要嚴格的類型形式。在 Python 中，我們可以將任何類型數(shù)據(jù)放入數(shù)組，但是在 Julia，我們只能將類型 T 放入到 Vector{T} 中。為了提供一般性，Julia 語言提供了各種非嚴格形式的類型。最明顯的案例就是 Any，任何滿足 T:
- a = Vector{Any}(undef,3)
- a[1] = 1.0
- a[2] = "hi!"
- a[3] = :Symbolic
- a
output:：
- 3-element Array{Any,1}:
- 1.0
- "hi!"
- :Symbolic
抽象類型的一種不太極端的形式是 Union 類型，例如：
- a = Vector{Union{Float64,Int}}(undef,3)
- a[1] = 1.0
- a[2] = 3
- a[3] = 1/4
- a
output：
- 3-element Array{Union{Float64, Int64},1}:
- 1.0
- 3
- 0.25
該案例只接受浮點型和整型數(shù)值，然而它仍然是一種抽象類型。一般在抽象類型上調(diào)用函數(shù)并不能知道任何元素的具體類型，例如在以上案例中每一個元素可能是浮點型或整型。因此通過多重分派實現(xiàn)優(yōu)化，編譯器并不能知道每一步的類型。因為不能完全優(yōu)化，Julia 語言和其它腳本語言一樣都會放慢速度。
這就是高性能原則：盡可能使用嚴格的類型。遵守這個原則還有其它優(yōu)勢：一個嚴格的類型 Vector{Float64} 實際上與 C/Fortran 是字節(jié)兼容的(byte-compatible)，因此它無需轉換就能直接用于 C/Fortran 程序。
高性能的成本
很明顯 Julia 語言做出了很明智的設計決策，因而在成為腳本語言的同時實現(xiàn)它的性能目標。然而，它到底損失了些什么?下一節(jié)將展示一些由該設計決策而產(chǎn)生的 Julia 特性，以及 Julia 語言各處的一些解決工具。
1. 可選的性能
前面已經(jīng)展示過，Julia 會通過很多方式實現(xiàn)高性能(例如 @inbounds)，但它們并不一定需要使用。我們可以使用類型不穩(wěn)定的函數(shù)，它會變得像 MATLAB/R/Python 那樣慢。如果我們并不需要***的性能，我們可以使用這些便捷的方式。
2. 檢測類型穩(wěn)定性
因為類型穩(wěn)定性極其重要，Julia 語言會提供一些工具以檢測函數(shù)的類型穩(wěn)定性，這在 @code_warntype 宏中是最重要的。下面我們可以檢測類型穩(wěn)定性：
- @code_warntype 2^5
- Body::Int64
- │220 1 ─ %1 = invoke Base.power_by_squaring(_2::Int64, _3::Int64)::Int64
- │ └── return %1
注意這表明函數(shù)中的變量都是嚴格類型，那么 expo 函數(shù)呢?
- @code_warntype 2^5
- Body::Union{Float64, Int64}
- │╻╷ >2 1 ─ %1 = (Base.slt_int)(0, y)::Bool
- │ └── goto #3 if not %1
- │ 3 2 ─ %3 = π (x, Int64)
- │╻ ^ │ %4 = invoke Base.power_by_squaring(%3::Int64, _3::Int64)::Int64
- │ └── return %4
- │ 5 3 ─ %6 = π (x, Int64)
- ││╻ Type │ %7 = (Base.sitofp)(Float64, %6)::Float64
- │ 6 │ %8 = π (%7, Float64)
- │╻ ^ │ %9 = (Base.sitofp)(Float64, y)::Float64
- ││ │ %10 = $(Expr(:foreigncall, "llvm.pow.f64", Float64, svec(Float64, Float64), :(:llvmcall), 2, :(%8), :(%9), :(%9), :(%8)))::Float64
- │ └── return %10
函數(shù)返回可能是 4% 和 10%，它們是不同的類型，所以返回的類型可以推斷為 Union{Float64,Int64}。為了準確追蹤不穩(wěn)定性產(chǎn)生的位置，我們可以使用 Traceur.jl：
- using Traceur
- @trace expo(2,5)
- ┌ Warning: x is assigned as Int64
- └ @ In[8]:2
- ┌ Warning: x is assigned as Float64
- └ @ In[8]:5
- ┌ Warning: expo returns Union{Float64, Int64}
- └ @ In[8]:2
output：32
這表明第 2 行 x 分派為整型 Int，而第 5 行它被分派為浮點型 Float64，所以類型可以推斷為 Union{Float64,Int64}。第 5 行是明確調(diào)用 convert 函數(shù)的位置，因此這為我們確定了問題所在。原文后面還介紹了如何處理不穩(wěn)定類型，以及全局變量 Globals 擁有比較差的性能，希望詳細了解的讀者可查閱原文。
結 論
設計上 Julia 很快。類型穩(wěn)定性和多重分派對 Julia 的編譯做特化很有必要，使其工作效率非常高。此外，魯棒性的類型系統(tǒng)同樣還需要在細粒度水平的類型上正常運行，因此才能盡可能實現(xiàn)類型穩(wěn)定性，并在類型不穩(wěn)定的情況下盡可能獲得更高的優(yōu)化。
原文鏈接：https://ucidatascienceinitiative.github.io/IntroToJulia/Html/WhyJulia
【本文是51CTO專欄機構“機器之心”的原創(chuàng)譯文，微信公眾號“機器之心( id: almosthuman2014)”】
