如果你看了上一篇《Go語言開發(fā)者的Apache Arrow使用指南：數據類型》[1]中的諸多Go操作arrow的代碼示例，你很可能會被代碼中大量使用的Retain和Release方法搞暈。不光大家有這樣的感覺，我也有同樣的feeling：**Go是GC語言[2]，為什么還要借助另外一套Retain和Release來進行內存管理呢**？

在這一篇文章中，我們就來探索一下這個問題的答案，并看看如何使用Retain和Release，順便再了解一下Apache Arrow的Go實現(xiàn)原理。

注：本文的內容基于Apache Arrow Go v13版本(go.mod中go version為v13)的代碼。

1. Go Arrow實現(xiàn)中的builder模式

看過第一篇文章中的代碼的童鞋可能發(fā)現(xiàn)了，無論是Primitive array type還是嵌套類型的諸如List array type，其array的創(chuàng)建套路都是這樣的：

• 首先創(chuàng)建對應類型的Builder，比如array.Int32Builder；
• 然后，向Builder實例中append值；
• 最后，通過Builder的NewArray方法獲得目標Array的實例，比如array.Int32。

據說這個builder模式是參考了Arrow的C++實現(xiàn)。這里將Go的builder模式中各個類型之間的關系以下面這幅示意圖的形式呈現(xiàn)一下：

圖片

當然這幅圖也大概可以作為Go Arrow實現(xiàn)的原理圖。

從圖中，我們可以看到：

• Arrow go提供了Builder、Array、ArrayData接口作為抽象，在這些接口中都包含了用作內存引用計數管理的Retain和Release方法；
• array包提供了Builder接口的一個默認實現(xiàn)builder類型，所有的XXXBuilder都組(內)合(嵌)了這個類型，這個類型實現(xiàn)了Retain方法，Release方法需要XXXBuilder自行實現(xiàn)。
• array包提供了Array接口的一個默認實現(xiàn)array類型，所有的array type(比如array.Int32)都組(內)合(嵌)了這個array類型。該類型實現(xiàn)了Retain和Release方法。

// github.com/apache/arrow/go/arrow/array/array.go
type array struct {
    refCount        int64
    data            *Data
    nullBitmapBytes []byte
}

// Retain increases the reference count by 1.
// Retain may be called simultaneously from multiple goroutines.
func (a *array) Retain() {
    atomic.AddInt64(&a.refCount, 1)
}

// Release decreases the reference count by 1.
// Release may be called simultaneously from multiple goroutines.
// When the reference count goes to zero, the memory is freed.
func (a *array) Release() {
    debug.Assert(atomic.LoadInt64(&a.refCount) > 0, "too many releases")

    if atomic.AddInt64(&a.refCount, -1) == 0 {
        a.data.Release()
        a.data, a.nullBitmapBytes = nil, nil
    }
}

下面以Int64 array type為例：

// github.com/apache/arrow/go/arrow/array/numeric.gen.go 

// A type which represents an immutable sequence of int64 values.
type Int64 struct {
    array // “繼承”了array的Retain和Release方法。
    values []int64
}

• 通過XXXBuilder類型的NewArray方法可以獲得該Builder對應的Array type實例，比如：調用Int32Builder的NewArray可獲得一個Int32 array type的實例。一個array type實例對應的數據是邏輯上immutable的，一旦創(chuàng)建便不能改變。
• 通過Array接口的Data方法可以得到該array type的底層數據layout實現(xiàn)(arrow.ArrayData接口的實現(xiàn))，包括child data。
• arrow包定義了所有的數據類型對應的ID值和string串，這個與arrow.DataType接口放在了一個源文件中。
• 另外要注意，XXXBuilder的實例是“一次性”的，一旦調用NewArray方法返回一個array type實例，該XXXBuilder就會被reset。如果再次調用其NewArray方法，只能得到一個空的array type實例。你可以重用該Builder，只需向該Builder實例重新append值即可(見下面示例)：

// reuse_string_builder.go

func main() {
    bldr := array.NewStringBuilder(memory.DefaultAllocator)
    defer bldr.Release()
    bldr.AppendValues([]string{"hello", "apache arrow"}, nil)
    arr := bldr.NewArray()
    defer arr.Release()
    bitmaps := arr.NullBitmapBytes()
    fmt.Println(hex.Dump(bitmaps))
    bufs := arr.Data().Buffers()
    for _, buf := range bufs {
        fmt.Println(hex.Dump(buf.Buf()))
    }
    fmt.Println(arr)

    // reuse the builder
    bldr.AppendValues([]string{"happy birthday", "leo messi"}, nil)
    arr1 := bldr.NewArray()
    defer arr1.Release()
    bitmaps1 := arr1.NullBitmapBytes()
    fmt.Println(hex.Dump(bitmaps1))
    bufs1 := arr1.Data().Buffers()
    for _, buf := range bufs1 {
        if buf != nil {
            fmt.Println(hex.Dump(buf.Buf()))
        }
    }
    fmt.Println(arr1)
}

輸出上面示例運行結果：

$go run reuse_string_builder.go
00000000  03                                                |.|

00000000  03 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
00000020  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|

00000000  00 00 00 00 05 00 00 00  11 00 00 00 00 00 00 00  |................|
00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
00000020  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|

00000000  68 65 6c 6c 6f 61 70 61  63 68 65 20 61 72 72 6f  |helloapache arro|
00000010  77 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |w...............|
00000020  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|

["hello" "apache arrow"]
00000000  03                                                |.|

00000000  03 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
00000020  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|

00000000  00 00 00 00 0e 00 00 00  17 00 00 00 00 00 00 00  |................|
00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
00000020  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|

00000000  68 61 70 70 79 20 62 69  72 74 68 64 61 79 6c 65  |happy birthdayle|
00000010  6f 20 6d 65 73 73 69 00  00 00 00 00 00 00 00 00  |o messi.........|
00000020  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|

["happy birthday" "leo messi"]

想必到這里，大家對Arrow的Go實現(xiàn)原理有了一個大概的認知了。接下來，我們再來看Go arrow實現(xiàn)的內存引用計數管理。

2. Go Arrow實現(xiàn)的內存引用計數管理

在上面圖中，我們看到Go Arrow實現(xiàn)的幾個主要接口Builder、Array、ArrayData都包含了Release和Retain方法，也就是說實現(xiàn)了這些接口的類型都支持采用引用計數方法(Reference Counting)進行內存的跟蹤和管理。Retain方法的語義是引用計數加1，而Release方法則是引用計數減1。由于采用了原子操作對引用計數進行加減，因此這兩個方法是并發(fā)安全的。當引用計數減到0時，該引用計數對應的內存塊就可以被釋放掉了。

Go Arrow實現(xiàn)的主頁[3]上對引用計數的使用場景和規(guī)則做了如下說明：

• 如果你被傳遞了一個對象并希望獲得它的所有權(ownership)，你必須調用Retain方法。當你不再需要該對象時，你必須調用對應的Release方法。"獲得所有權"意味著你希望在當前函數調用的范圍之外訪問該對象。
• 你通過名稱以New或Copy開頭的函數創(chuàng)建的任何對象，或者在通過channel接收對象時，你都將擁有所有權。因此，一旦你不再需要這個對象，你必須調用Release。
• 如果你通過一個channel發(fā)送一個對象，你必須在發(fā)送之前調用Retain，因為接收者將擁有該對象。接收者有義務在以后不再需要該對象時調用Release。

有了這個說明后，我們對于Retain和Release的使用場景基本做到心里有譜了。但還有一個問題亟待解決，那就是：Go是GC語言，為何還要在GC之上加上一套引用計數呢？

這個問題我在這個issue[4]中找到了答案。一個Go arrow實現(xiàn)的commiter在回答issue時提到：“理論上，如果你知道你使用的是默認的Go分配器，你實際上不必在你的消費者(指的是Arrow Go包 API的使用者)代碼中調用Retain/Release，可以直接讓Go垃圾回收器管理一切。我們只需要確保我們在庫內調用Retain/Release，這樣如果消費者使用非Go GC分配器，我們就可以確保他們不會出現(xiàn)內存泄漏”。

下面是默認的Go分配器的實現(xiàn)代碼：

package memory

// DefaultAllocator is a default implementation of Allocator and can be used anywhere
// an Allocator is required.
//
// DefaultAllocator is safe to use from multiple goroutines.
var DefaultAllocator Allocator = NewGoAllocator()

type GoAllocator struct{}

func NewGoAllocator() *GoAllocator { return &GoAllocator{} }

func (a *GoAllocator) Allocate(size int) []byte {
    buf := make([]byte, size+alignment) // padding for 64-byte alignment
    addr := int(addressOf(buf))
    next := roundUpToMultipleOf64(addr)
    if addr != next {
        shift := next - addr
        return buf[shift : size+shift : size+shift]
    }
    return buf[:size:size]
}

func (a *GoAllocator) Reallocate(size int, b []byte) []byte {
    if size == len(b) {
        return b
    }

    newBuf := a.Allocate(size)
    copy(newBuf, b)
    return newBuf
}

func (a *GoAllocator) Free(b []byte) {}

我們看到默認的Allocator只是分配一個原生切片，并且切片的底層內存塊要保證64-byte對齊。

但為什么Retain和Release依然存在且需要調用呢？這位commiter給出了他理解的幾點原因：

• 允許用戶控制buffer和內部數據何時被設置為nil，以便在可能的情況下提前標記為可被垃圾收集；
• 如果用戶愿意，允許正確使用不依賴Go垃圾收集器的分配器（比如mallocator實現(xiàn)，它使用malloc/free來管理C內存而不是使用Go垃圾收集來管理）；
• 雖然用戶可以通過SetFinalizer來使用Finalizer進行內存釋放，但一般來說，我們建議最好有一個顯式的釋放動作，而不是依賴finalizer，因為沒有實際保證finalizer會運行。此外，finalizer只在GC期間運行，這意味著如果你的分配器正在分配C內存或其他東西，而Go內存一直很低，那么你有可能在任何finalizer運行以實際調用Free之前，就被分配了大量的C內存，從而耗盡了你的內存。

基于這些原因，Go Arrow實現(xiàn)保留了Retain和Release，雖然有上門的一些場景使用方法，但這兩個方法的加入一定程度上增加了Go Arrow API使用的門檻。并且在重度使用Go Arrow實現(xiàn)的程序中，大家務必對程序做穩(wěn)定性長測試驗證，以確保memory沒有l(wèi)eak。

3. 如何實現(xiàn)ZeroCopy的內存數據共享

《In-Memory Analytics with Apache Arrow》[5]一書在第二章中提到了采用Arrow實現(xiàn)zerocopy的內存數據共享的原理，這里將其稱為“切片(slice)原理”，用書中的例子簡單描述就是這樣的：假設你想對一個有數十億行的非常大的數據集進行一些分析操作。提高這種操作性能的一個常見方法是對行的子集進行并行操作，即僅通過對數組和數據緩沖區(qū)進行切分，而不需要復制底層數據。這樣你操作的每個批次都不是一個副本--它只是數據的一個視圖。書中還給出了如下示意圖：

圖片

右側切片列中的每個切片的虛線表示它們只是各自列中的數據子集的視圖，每個切片都可以安全地進行并行操作。

array type是邏輯上immutable的，底層data buffer一旦建立后，便可以通過切片的方式來以zerocopy方式做內存數據共享，極大提高了數據操作的性能。

4. 小結

本文介紹了Go arrow實現(xiàn)的主要結構以及實現(xiàn)模式：builder模式，并結合Go arrow官方資料說明了采用引用計數進行內存管理的原因與使用方法，最后介紹了Arrow實現(xiàn)ZeroCopy的內存數據共享的原理。這些將為后續(xù)繼續(xù)深入學習Arrow高級數據類型/結構奠定良好的基礎。

注：本文涉及的源代碼在這里[6]可以下載。

Gopher Daily(Gopher每日新聞)歸檔倉庫 - https://github.com/bigwhite/gopherdaily

我的聯(lián)系方式：

• 微博(暫不可用)：https://weibo.com/bigwhite20xx
• 微博2：https://weibo.com/u/6484441286
• 博客：tonybai.com
• github: https://github.com/bigwhite

參考資料

[1] 《Go語言開發(fā)者的Apache Arrow使用指南：數據類型》: https://tonybai.com/2023/06/25/a-guide-of-using-apache-arrow-for-gopher-part1

[2] Go是GC語言: https://tonybai.com/2023/06/13/understand-go-gc-overhead-behind-the-convenience

[3] Go Arrow實現(xiàn)的主頁: https://github.com/apache/arrow/tree/main/go

[4] 這個issue: https://github.com/apache/arrow/issues/35232

[5] 《In-Memory Analytics with Apache Arrow》: https://book.douban.com/subject/35954154/

[6] 這里: https://github.com/bigwhite/experiments/blob/master/arrow/memory-management

[7] “Gopher部落”知識星球: https://wx.zsxq.com/dweb2/index/group/51284458844544

[8] 鏈接地址: https://m.do.co/c/bff6eed92687

本文轉載自微信公眾號「TonyBai」，可以通過以下二維碼關注。轉載本文請聯(lián)系TonyBai公眾號。