# 關(guān)注并星標(biāo)騰訊云開發(fā)者

(資料圖)

# 每周1 | 鵝廠工程師帶你審判技術(shù)

#第1期|李志瑞：AI 屆新語言 Mojo 要火？?

前段時間 Modular 發(fā)布了一個新語言 Mojo，這語言不止官網(wǎng)放了巨大的 emoji ?，而且它的標(biāo)準(zhǔn)文件后綴一個是「.mojo」另一個是「.?」，一副立馬要火的樣子呢。

說實(shí)話，這個用 emoji 做后綴名的操作其實(shí)挺無聊，也有點(diǎn)敗好感，但如果說這個語言能在完全兼容 Python 的基礎(chǔ)上大幅提高執(zhí)行效率，并且作者是 LLVM 發(fā)起人 Chris Lattner，是不是突然又有興趣繼續(xù)了解它了呢？

Mojo 被設(shè)計為 Python 語言的超集，并增加了許多特性，包括：

?? Progressive types：能利用類型信息獲得更好性能和靜態(tài)檢查，但又不強(qiáng)制要求寫類型。

?? Zero cost abstractions：C++ 的核心設(shè)計準(zhǔn)則，能夠避免用戶為了性能放棄合理設(shè)計的代碼。

?? Ownership + borrow checker：Rust 語言的安全性來源，在編譯期避免許多錯誤的發(fā)生。

?? The full power of MLIR：原生支持對 MLIR 的直接訪問，能夠從底層擴(kuò)展系統(tǒng)。

在 Mojo 這個語言的介紹中反復(fù)提到 AI，官網(wǎng)也說它是「a new programming language for all AI developers」。那么為什么 AI 開發(fā)需要一個新語言呢？首先，我們知道在 AI 屆具有統(tǒng)治地位的語言就是 Python，Python 是一個語法簡單清晰，容易上手，且靈活度很高的語言，深受廣大程序員喜愛，XKCD 上有就這么一幅漫畫：

當(dāng)然，受人喜愛的語言有很多，Python 成為 AI 屆的統(tǒng)治語言除了本身易用之外，也有慣性的因素。由于 Python 上機(jī)器學(xué)習(xí)相關(guān)的庫多，因此機(jī)器學(xué)習(xí)從業(yè)者用的就多，這又反過來令新的機(jī)器學(xué)習(xí)相關(guān)庫優(yōu)先為 Python 提供接口，進(jìn)一步加強(qiáng)了其統(tǒng)治地位。因此，為了逐步滲透這個用戶群，Mojo 兼容 Python 是很正確的一個選擇。Mojo 不僅承諾語法是 Python 的超集，并且它還能直接調(diào)用 Python 的庫，這意味著 Mojo 不需要從零開始構(gòu)建自己的生態(tài)，本身就可以用上繁榮的 Python 生態(tài)了。

雖然 Python 很好，但它有一個眾所周知的問題，那就是太慢了。而機(jī)器學(xué)習(xí)本身又需要繁重的計算，因此 Python 生態(tài)中大量庫的底層其實(shí)都是用高性能的語言（如 C/C++）進(jìn)行實(shí)現(xiàn)，然后再提供一個 Python 接口供用戶調(diào)用，典型的如 numpy 這種數(shù)學(xué)庫。在這種情況下，Python 事實(shí)上是被作為一個膠水語言來使用，這造成了開發(fā)的碎片化，如果一個用戶只是簡單調(diào)一下庫那還好說，但一旦到了工業(yè)界，開發(fā)過程中不可避免地就要涉及一些底層庫的修改，甚至直接換語言來實(shí)現(xiàn)同樣的功能以提高性能，這種割裂不止增加了開發(fā)成本和精神負(fù)擔(dān)，而且考慮到眾多擅長 C/C++ 語言的開發(fā)者也并不是 AI 領(lǐng)域?qū)＜遥@種開發(fā)人員能力的不適配也對整個 AI 生態(tài)的發(fā)展形成了一定阻礙。

因此，Mojo 的目的就是要在 Python 生態(tài)的基礎(chǔ)上，讓用戶能用一個語言，從使用易用的接口，到開發(fā)復(fù)雜的庫，再到實(shí)現(xiàn)底層黑科技，統(tǒng)一實(shí)驗(yàn)和生產(chǎn)環(huán)境所用的語言。為了實(shí)現(xiàn)這個目的，Mojo 擴(kuò)展了 Python 語法，支持了緊湊的內(nèi)存布局，并引入了一些現(xiàn)代的語言特性（例如 Rust 的安全性檢查），使得這個語言能夠漸進(jìn)式地在 AI 界立足。說起來 Chris Lattner 在這方面可以算是經(jīng)驗(yàn)豐富了，不管是在 gcc/msvc 的統(tǒng)治下實(shí)現(xiàn) clang，還是在 objective-c 的統(tǒng)治下為蘋果實(shí)現(xiàn) swift，都是一個逐步蠶食對手市場的過程。

說了這么多，該來看看 Mojo 長什么樣了?，F(xiàn)在 Mojo 還不能直接下載使用，如果想要嘗鮮，需要在官網(wǎng)申請，然后在 playground 頁面中試用，這是一個基于 Jupyter 的頁面，可以混合筆記和可執(zhí)行的 Mojo 代碼。

前面提到，Mojo 的語法是 Python 的超集，因此 Mojo 的 Hello World 也跟 Python 一樣簡單：

print("Hello World") #> Hello World

與 Python 一樣，Mojo 也使用換行符和縮進(jìn)來定義代碼塊：

fn foo():var x: Int = 1x += 1let y: Int = 1print(x, y)  #> 2 1foo()

上面的代碼中使用 var 來聲明變量 x，使用 let 來聲明了不可變量 y。Mojo 像很多較新近的語言一樣，讓不可變量的聲明變得簡單，以鼓勵開發(fā)者使用不可變的量。另外注意到這里定義函數(shù)使用了 fn 而非 Python 的 def，這是因?yàn)?Mojo 希望在兼容 Python 的基礎(chǔ)上加入編譯期的檢查和優(yōu)化，而 Python 過于動態(tài)的語法很難支持這一目標(biāo)，因此，Mojo 同時支持使用 fn 和 def 兩個關(guān)鍵字來聲明函數(shù)，對于調(diào)用者來說，這兩種方法聲明出來的函數(shù)沒有什么區(qū)別，但對于實(shí)現(xiàn)者來說，可以將 fn 看作「嚴(yán)格模式」下的 def，例如下面的代碼會編譯錯誤（如果改成用 def 則不會出錯）：

fn foo(): x = 1 print(x) #error:Expression[12]:6:5:useofunknowndeclaration"x","fn"declarationsrequireexplicitvariabledeclarations#x=1#^

雖然官方承諾 Mojo 的語法是 Python 的超集，但目前 Mojo 還在開發(fā)中，很多 Python 語法都還不支持，例如目前連 Python 的 class 都無法被編譯通過：

class MyClass:def foo():pass# error: Expression [15]:17:5: classes are not supported yet#     class MyClass:#     ^

不過，Mojo 現(xiàn)在先提供了另一個用來組織數(shù)據(jù)的關(guān)鍵字 struct，相比于 class，struct 更加靜態(tài)可控，便于優(yōu)化。一方面，struct 支持類似 Python class 風(fēng)格的函數(shù)聲明和運(yùn)算符重載。而另一方面，struct 又類似于 C++ 的 struct 和 class，內(nèi)部的成員在內(nèi)存中緊湊排布，而且不支持在運(yùn)行時動態(tài)添加成員和方法，便于編譯期進(jìn)行優(yōu)化，例如：

struct MyIntPair:var first: Intvar second: Intfn __init__(inout self, first: Int, second: Int):self.first = firstself.second = secondfn __lt__(self, rhs: MyIntPair) -> Bool:return self.first < rhs.first or(self.first == rhs.first andself.second < rhs.second)let p1 = MyIntPair(1, 2)let p2 = MyIntPair(2, 1)if p1 < p2: print("p1 < p2")  #> p1 < p2

雖然有點(diǎn)不同，但整體上看起來還是非常熟悉的對吧。說到這里，有一點(diǎn)需要提醒各位注意，盡管 Mojo 之后會令語法成為 Python 語法的超集，但其語義則有時會和 Python 不同，這意味著 Python 的代碼直接拷到 Mojo 里可能會出現(xiàn)編譯通過但執(zhí)行結(jié)果不同的情況，這里簡單提一個比較常見的例子：函數(shù)傳參。在 Python 中，函數(shù)傳參的語義類似于 C++ 的傳指針，在函數(shù)內(nèi)部雖然不能更改調(diào)用者指向的對象，但可以改變該對象內(nèi)部的狀態(tài)，例如下面的代碼：

def foo(lst):lst[0] = 5print(lst)x = [1, 2, 3]foo(x)print(x)

在 Python 中，這段代碼打印出來的結(jié)果是兩次 [5, 2, 3]。但在 Mojo 中，使用 def 定義的函數(shù)默認(rèn)的傳遞邏輯是復(fù)制值，也就是說，盡管在函數(shù)中能夠修改參數(shù)內(nèi)部的狀態(tài)，但修改對于調(diào)用方來說是不可見的，因此上面這段代碼在 Mojo 中打印的結(jié)果是 [5, 2, 3]（foo 內(nèi)部）和 [1, 2, 3]（foo 外部）。

除了語法像 Python，Mojo 非常務(wù)實(shí)的一點(diǎn)在于它構(gòu)建于 Python 的生態(tài)之上。因此即便 Mojo 還沒能完整支持 Python 的語法，它還是優(yōu)先支持了對 Python 庫的調(diào)用，以便讓開發(fā)者能受益于龐大完善的 Python 的生態(tài)。例如下面的代碼就使用了 Python 的 numpy 庫：

fromPythonInterfaceimportPythonlet np = Python.import_module("numpy")ar = np.arange(15).reshape(3, 5)print(ar.shape)   #> (3, 5)

Mojo 作為一個新語言，廣泛吸收許多現(xiàn)代的程序語言設(shè)計思想，例如 Rust 的所有權(quán)和借用檢查，以此提升代碼的安全性。在 Mojo 中，使用 fn 定義的函數(shù)的參數(shù)默認(rèn)傳的是不可變的引用，即「借用」，調(diào)用方仍然擁有其所有權(quán)，因此在函數(shù)內(nèi)部不可以對參數(shù)進(jìn)行修改。Mojo 提供了一個 borrow 關(guān)鍵字來標(biāo)注這樣的參數(shù)傳遞情況，對于 fn 來說是可以省略的，也就是說下面 foo 函數(shù)中兩個參數(shù)的傳遞方式相同：

fn foo(borrowed a: SomethingBig, b: SomethingBig):a.use()b.use()

在 Rust 中，傳參的默認(rèn)行為是移動，如果需要借用則需要在傳入時加上 &，這兩種方式倒是沒有太大的優(yōu)劣之分，Mojo 的行為可能更接近于 Python 這類高級語言的習(xí)慣。如果想要修改傳入的參數(shù)，則需要手動注明 inout，例如：

fn swap(inout lhs: Int, inout rhs: Int):let tmp = lhslhs = rhsrhs = tmpfn test_swap():var x = 42var y = 12print(x, y)  #> 42, 12swap(x, y)print(x, y)  #> 12, 42test_swap()

按道理說，Mojo 應(yīng)該像 Rust 一樣規(guī)避一個變量同時被可變和不可變借用，也應(yīng)該規(guī)避同時被可變借用，但目前 Mojo 編譯器似乎還沒實(shí)現(xiàn)這一特性，例如下面的代碼還是能編譯通過的：

var x = 42swap(x,x)

從這也可以看出 Mojo 確實(shí)還處在比較早期的發(fā)展階段。

另一個重要的內(nèi)存安全概念是對象的所有權(quán)，當(dāng)一個函數(shù)獲取了對象的所有權(quán)后，調(diào)用方就不應(yīng)該再去使用這個對象了，例如我們實(shí)現(xiàn)了一個只支持移動的類型 UniquePtr：

struct UniquePtr:var ptr: Intfn __init__(inout self, ptr: Int):self.ptr = ptrfn __moveinit__(inout self, owned existing: Self):self.ptr = existing.ptrfn __del__(owned self):self.ptr = 0

同時，我們有兩個函數(shù)，其中，use_ptr 使用了前面提到的 borrow 關(guān)鍵字，借用了 UniquePtr 對象，而 take_ptr 則使用 owned 關(guān)鍵字，指明它需要獲取傳入對象的所有權(quán)。那么，在調(diào)用 take_ptr 的時候，我們就需要在參數(shù)后面加上 ^ 后綴，用來表明我們將所有權(quán)轉(zhuǎn)移給 take_ptr：

fn use_ptr(borrowed p: UniquePtr):print(p.ptr)fn take_ptr(owned p: UniquePtr):print(p.ptr)fn test_ownership():let p = UniquePtr(100)use_ptr(p)    #> 100take_ptr(p^)  #> 100test_ownership()

因此，如果我們將 use_ptr 和 take_ptr 的調(diào)用順序調(diào)換一下，就會出現(xiàn)編譯錯誤：

fn test_ownership():let p = UniquePtr(100)take_ptr(p^)use_ptr(p)    # ERROR!test_ownership()# error: Expression [13]:23:12: use of uninitialized value "p"#    use_ptr(p) # ERROR: p is no longer valid here!#            ^

Mojo 的另一個強(qiáng)大之處在于它讓對 MLIR>) 的操作變得更簡單。MLIR 全稱是 Multi-Level Intermediate Representation，是一個編譯器開發(fā)框架，它存在的目的是通過定義多種方言來逐級將代碼轉(zhuǎn)換為機(jī)器碼，以降低編譯器的開發(fā)成本。在 MLIR 之前，一個廣為人熟知的 IR 是 LLVM IR，一個語言的編譯器作者可以通過將自己的語言編譯為 LLVM IR 來接入 LLVM 的工具鏈，使得編譯器作者不需要關(guān)心底層具體硬件的差別，實(shí)現(xiàn)了對底層編譯工具鏈的復(fù)用：

但 LLVM IR 層級過低，難以進(jìn)行特定于語言本身的優(yōu)化，從上面的圖中也能看出，各個語言為了實(shí)現(xiàn)語言本身的優(yōu)化，都在編譯為 LLVM IR 之前加入了自己的 IR。另外 LLVM IR 擴(kuò)展起來也非常困難，難以適應(yīng)復(fù)雜異構(gòu)計算的要求，而異構(gòu)計算在 AI 開發(fā)中又非常普遍。MLIR 相比于之前的 IR，更加模塊化，僅保留了一個非常小的內(nèi)核，方便開發(fā)者進(jìn)行擴(kuò)展。很多編譯器將代碼編譯為 MLIR，而 Mojo 提供了直接訪問 MLIR 的能力，這使得 Mojo 能夠受益于這些工具。更多關(guān)于 MLIR 的內(nèi)容可以參考這一系列文章：編譯器與中間表示: LLVM IR, SPIR-V, 以及 MLIR，這里就不做過多贅述，我們主要關(guān)注在 Mojo 中可以如何操作 MLIR。舉例而言，如果我們希望實(shí)現(xiàn)一個新的 boolean 類型 OurBool，我們可以這樣實(shí)現(xiàn)：

alias OurTrue: OurBool = __mlir_attr.`true`alias OurFalse: OurBool = __mlir_attr.`false`@register_passable("trivial")struct OurBool:var value: __mlir_type.i1fn __init__() -> Self:return OurFalsefn __init__(value: __mlir_type.i1) -> Self:return Self {value: value}fn __bool__(self) -> Bool:return Bool(self.value)

這里定義了一個類型為 OurBool 的類型，里面有一個直接使用 MLIR 內(nèi)置類型 i1 的成員 value 。在 Mojo 中，我們可以通過 __mlir_type.typename 的形式來訪問 MLIR 類型。接著，我們?yōu)檫@個類型提供了兩個構(gòu)造函數(shù)，默認(rèn)情況下構(gòu)造為 OurFalse 也可基于傳入的參數(shù)進(jìn)行構(gòu)建。最下面的 __bool__ 也和 Python 的 __bool__ 一樣，用于使該類型具有和內(nèi)置 boolean 類型的性質(zhì)，此時我們可以這樣使用它：

let t: OurBool = OurTrueif t: print("true")  #> true

除了使用 MLIR 之外，Mojo 甚至可以允許開發(fā)者使用 MLIR 實(shí)現(xiàn)邏輯，例如下面的代碼中通過應(yīng)用 MLIR 的 index.casts 操作來實(shí)現(xiàn)類型轉(zhuǎn)換，然后再通過 index.cmp 對值進(jìn)行比較：

# ...struct OurBool:# ...fn __eq__(self, rhs: OurBool) -> Self:let lhsIndex = __mlir_op.`index.casts`[_type : __mlir_type.index](self.value)let rhsIndex = __mlir_op.`index.casts`[_type : __mlir_type.index](rhs.value)return Self(__mlir_op.`index.cmp`[pred : __mlir_attr.`#index`](lhsIndex, rhsIndex))

基于封裝好的 __eq__ 方法，我們可以很容易實(shí)現(xiàn) __invert__ 方法：

# ...struct OurBool:# ...fn __invert__(self) -> Self:return OurFalse if self == OurTrue else OurTrue

此時，我們就可以對 OurBool 類型的對象使用 ~ 操作符了：

let f = OurFalseif ~f: print("false")  #> false

通過這個簡單的例子我們可以看出，在 Mojo 中，開發(fā)者可以通過訪問 MLIR 來實(shí)現(xiàn)和內(nèi)置類型同等高效的類型。這使得開發(fā)者可以在 Mojo 上為新硬件的數(shù)據(jù)類型封裝高效簡單的 Mojo 接口而不需要切換語言。雖然大部分開發(fā)者并不需要接觸 MLIR，但 Mojo 為更深入和更底層的優(yōu)化提供了充分的可能性。

雖然 Mojo 反復(fù)強(qiáng)調(diào)它是為 AI 設(shè)計的新語言，但以目前 Mojo 的設(shè)計方向來看，它的發(fā)展前景并不止于 AI。本質(zhì)上 Mojo 提供了一個能夠兼容 Python 生態(tài)的高性能語言，且這個語言可以讓 Python 開發(fā)者幾乎無痛地切換過去，那 Python 開發(fā)者何樂而不為呢？對于使用 Mojo 的開發(fā)者來說，上層業(yè)務(wù)可以將 Mojo 當(dāng) Python 一樣使用，享受到簡明的語法帶來的高開發(fā)效率，當(dāng)出現(xiàn)性能瓶頸的時候，也不用切換語言去進(jìn)行優(yōu)化，直接使用 Mojo 重構(gòu)模塊即可。雖然現(xiàn)在還沒法在生產(chǎn)環(huán)境中驗(yàn)證這個想法，但這個未來聽起來確實(shí)非常美好。關(guān)于 Mojo 和 Python 開發(fā)性能的對比，您可瀏覽 Mojo 發(fā)布會上的 Jeremy Howard demo for Mojo launch 視頻。

目前 Mojo 還在比較早期的階段，不僅許多語言特性都還沒實(shí)現(xiàn)，而且連本地開發(fā)的套件都沒有提供。不過其發(fā)展路線和設(shè)計思路都非常務(wù)實(shí) ，又有一個足夠?qū)I(yè)的領(lǐng)導(dǎo)者和公司作為背景支撐，可以說是未來可期，也非常希望這個語言能在其他領(lǐng)域得到更廣泛的應(yīng)用。

關(guān)鍵詞：