go?variant底層原理深入解析

更新時間：2022年11月23日 11:10:11 作者：用戶楊杰

這篇文章主要為大家介紹了go?variant底層原理深入解析，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪

varint

今天本來在研究 OpenTelemetry 的基準性能測試 github.com/zdyj3170101…，測試不同網絡協(xié)議:grpc, grpc-stream, http, websocket 在發(fā)送不同大小數據包時消耗 cpu，吞吐的區(qū)別，由 tigrannajaryan 這位大神所寫。

好奇翻了翻該大神的 github 倉庫，發(fā)現了一個同樣神奇的庫。

這個庫也是基準的性能測試，用來測試 go 中不同方法實現的多類型變量在消耗 cpu 以及內存上的區(qū)別。

旨在實現一個能存儲多類型變量并且具有最小 cpu 消耗以及內存消耗的數據結構。

github.com/tigrannajar…

benchmarks

Interface: 接口
struct：struct，多個 field 存放不同類型的結構體
variant：該庫的時間

struct

struct 是一個結構體，typ 表示當前結構體的類型，不同的 field 分別存儲不同的類型。

type Variant struct {
   typ   variant.Type
   bytes []byte
   str   string
   i     int
   f     float64
}

struct 還有兩種不同的類型。

根據是否返回指針分別為 plainstruct 和 ptrstruct。

而 ptrstruct 相比 plainstruct 就多出一次內存分配，以及增加 cpu 耗時（棧上內存分配幾個移位指令就能完成）。

func StringVariant(v string) Variant {
  return Variant{typ: variant.TypeString, str: v}
} 
?
func StringVariant(v string) *Variant {
  return &Variant{typ: variant.TypeString, str: v}
}

進行 benchmark 后發(fā)現 plainstruct 已經 0 byte 分配了，我也想不出還有其他的優(yōu)化思路。

yangjie05-mac:plainstruct jie.yang05$ go test -bench=. -benchmem plainstruct_test.go  plainstruct.go
Variant size=64 bytes
goos: darwin
goarch: amd64
cpu: VirtualApple @ 2.50GHz
BenchmarkVariantIntGet-10                       1000000000               0.3111 ns/op          0 B/op          0 allocs/op
BenchmarkVariantFloat64Get-10                   1000000000               0.3117 ns/op          0 B/op          0 allocs/op
BenchmarkVariantIntTypeAndGet-10                1000000000               0.3189 ns/op          0 B/op          0 allocs/op
BenchmarkVariantStringTypeAndGet-10             141588165                8.435 ns/op           0 B/op          0 allocs/op
BenchmarkVariantBytesTypeAndGet-10              140932470                8.465 ns/op           0 B/op          0 allocs/op
BenchmarkVariantIntSliceGetAll-10                7293846               165.7 ns/op           640 B/op          1 allocs/op
BenchmarkVariantIntSliceTypeAndGetAll-10         7491408               170.6 ns/op           640 B/op          1 allocs/op
BenchmarkVariantStringSliceTypeAndGetAll-10      7061575               170.1 ns/op           640 B/op          1 allocs/op
?

variant

一個 variant 由指向真實數據的指針 ptr，一個緊湊的 lenandtype 同時表示長度和類型，這個數據結構還根據不同位的系統(tǒng)做了優(yōu)化，以及 capOrVal(在slice類型數據時，就是 cap，非slice類型數據時就是val )。

32位系統(tǒng)下，type 占3位，len 用29位表示
64 位系統(tǒng)下，type占3位，len用63位表示。

Variant 設計主要是為了同時滿足存儲 float64 和 string 的需求。因為 float64 的存在，必須要有一個 int64 類型的字段存儲 float64 的值。而 string 的 len 是int類型的字段，就不需要用int64。

type Variant struct {
  // Pointer to the slice start for slice-based types.
  ptr unsafe.Pointer
?
  // Len and Type fields.
  // Type uses `typeFieldBitCount` least significant bits, Len uses the rest.
  // Len is used only for the slice-based types.
  lenAndType int
?
  // Capacity for slice-based types, or the value for other types. For Float64Val type
  // contains the 64 bits of the floating point value.
  capOrVal int64
}

比如創(chuàng)建一個string的時候，ptr 中存放指向數據的指針，而lenAndType 中存儲slice的長度以及 type。 ``

// NewString creates a Variant of TypeString type.
func NewString(v string) Variant {
  hdr := (*reflect.StringHeader)(unsafe.Pointer(&v))
  if hdr.Len > maxSliceLen {
    panic("maximum len exceeded")
  }
?
  return Variant{
    ptr:        unsafe.Pointer(hdr.Data),
    lenAndType: (hdr.Len << typeFieldBitCount) | int(TypeString),
  }
}

為什么 variant 要比 plainstruct 快

分別測試 variant 和 plainstruct 創(chuàng)建 string 的性能：

func createVariantString() Variant { // 防止編譯優(yōu)化掉？
   for i := 0; i < 1; i++ {
      return StringVariant(testutil.StrMagicVal)
   }
   return StringVariant("def")
}
func BenchmarkVariantStringTypeAndGet(b *testing.B) {
   for i := 0; i < b.N; i++ {
      v := createVariantString()
      if v.Type() == variant.TypeString {
         if v.String() == "" {
            panic("empty string")
         }
      } else {
         panic("invalid type")
      }
   }
}

使用 go tool 做性能測試，并查看plainstruct的profile文件：

go test -o=bin -bench=. -v -test.cpuprofile=cpuprofile plainstruct_test.go plainstruct.go
go tool pprof -http=:  bin cpuprofile

同理 variant：

go test -o=bin -bench=. -v -test.cpuprofile=cpuprofile variant_test.go variant.go variant_64.go
 go tool pprof -http=:  bin cpuprofile

variant 的匯編:

plainstruct的匯編：

主要區(qū)別還是plainstrutc的指令數太多，因為struct的字段更多。

variant 可能的優(yōu)化？

variant 其實這里還有一個優(yōu)化的方向，就是在 32 位機器存儲 float64 的時候。將 float64 拆成兩個 int32，分別用 ptr 和 capOrVal 來存儲。這樣在 32位系統(tǒng)下，capOrVal 可以由 int64 變成 int，節(jié)省了 4 個字節(jié)。

type Variant struct {
  // Pointer to the slice start for slice-based types.
  ptr unsafe.Pointer
  // Len and Type fields.
  // Type uses `typeFieldBitCount` least significant bits, Len uses the rest.
  // Len is used only for the slice-based types.
  lenAndType int
  capOrVal int
}

以上就是go variant原理深入解析的詳細內容，更多關于go variant的資料請關注腳本之家其它相關文章！

您可能感興趣的文章: