Go反射：性能瓶颈与零拷贝优化

// TypeOf returns the reflection [Type] that represents the dynamic type of i.
// If i is a nil interface value, TypeOf returns nil.
func TypeOf(i any) Type {
 return toType(abi.TypeOf(i))
}

// rtype is the common implementation of most values.
// It is embedded in other struct types.
type rtype struct {
 t abi.Type
}

func toRType(t *abi.Type) *rtype {
 return (*rtype)(unsafe.Pointer(t))
}

// Type is the runtime representation of a Go type.
//
// Be careful about accessing this type at build time, as the version
// of this type in the compiler/linker may not have the same layout
// as the version in the target binary, due to pointer width
// differences and any experiments. Use cmd/compile/internal/rttype
// or the functions in compiletype.go to access this type instead.
// (TODO: this admonition applies to every type in this package.
// Put it in some shared location?)
type Type struct {
 Size_       uintptr
 PtrBytes    uintptr // number of (prefix) bytes in the type that can contain pointers
 Hash        uint32  // hash of type; avoids computation in hash tables
 TFlag       TFlag   // extra type information flags
 Align_      uint8   // alignment of variable with this type
 FieldAlign_ uint8   // alignment of struct field with this type
 Kind_       Kind    // enumeration for C
 // function for comparing objects of this type
 // (ptr to object A, ptr to object B) -> ==?
 Equal func(unsafe.Pointer, unsafe.Pointer) bool
 // GCData stores the GC type data for the garbage collector.
 // Normally, GCData points to a bitmask that describes the
 // ptr/nonptr fields of the type. The bitmask will have at
 // least PtrBytes/ptrSize bits.
 // If the TFlagGCMaskOnDemand bit is set, GCData is instead a
 // **byte and the pointer to the bitmask is one dereference away.
 // The runtime will build the bitmask if needed.
 // (See runtime/type.go:getGCMask.)
 // Note: multiple types may have the same value of GCData,
 // including when TFlagGCMaskOnDemand is set. The types will, of course,
 // have the same pointer layout (but not necessarily the same size).
 GCData    *byte
 Str       NameOff // string form
 PtrToThis TypeOff // type for pointer to this type, may be zero
}

type StructField struct {
 Name   Name    // name is always non-empty
 Typ    *Type   // type of field
 Offset uintptr // byte offset of field
}

type StructType struct {
 Type
 PkgPath Name
 Fields  []StructField
}

// Struct field
type structField = abi.StructField // 注意：你平时用的是 reflect.structField，不是reflect.StructField

// structType represents a struct type.
type structType struct {
 abi.StructType
}

func (t *rtype) Field(i int) StructField {
 if t.Kind() != Struct {
  panic("reflect: Field of non-struct type " + t.String())
 }
 tt := (*structType)(unsafe.Pointer(t))
 return tt.Field(i)
}

// Field returns the i'th struct field.
func (t *structType) Field(i int) (f StructField) {
 if i < 0 || i >= len(t.Fields) {
  panic("reflect: Field index out of bounds")
 }
 p := &t.Fields[i]
 f.Type = toType(p.Typ)
 f.Name = p.Name.Name()
 f.Anonymous = p.Embedded()
 if !p.Name.IsExported() {
  f.PkgPath = t.PkgPath.Name()
 }
 if tag := p.Name.Tag(); tag != "" {
  f.Tag = StructTag(tag)
 }
 f.Offset = p.Offset

 // We can't safely use this optimization on js or wasi,
 // which do not appear to support read-only data.
 if i < 256 && runtime.GOOS != "js" && runtime.GOOS != "wasip1" {
  staticuint64s := getStaticuint64s()
  p := unsafe.Pointer(&(*staticuint64s)[i])
  if unsafe.Sizeof(int(0)) == 4 && goarch.BigEndian {
   p = unsafe.Add(p, 4)
  }
  f.Index = unsafe.Slice((*int)(p), 1)
 } else {
  // NOTE(rsc): This is the only allocation in the interface
  // presented by a reflect.Type. It would be nice to avoid,
  // but we need to make sure that misbehaving clients of
  // reflect cannot affect other uses of reflect.
  // One possibility is CL 5371098, but we postponed that
  // ugliness until there is a demonstrated
  // need for the performance. This is issue 2320.
  f.Index = []int{i}
 }
 return
}

// A StructTag is the tag string in a struct field.
//
// By convention, tag strings are a concatenation of
// optionally space-separated key:"value" pairs.
// Each key is a non-empty string consisting of non-control
// characters other than space (U+0020 ' '), quote (U+0022 '"'),
// and colon (U+003A ':').  Each value is quoted using U+0022 '"'
// characters and Go string literal syntax.
type StructTag string

// Get returns the value associated with key in the tag string.
// If there is no such key in the tag, Get returns the empty string.
// If the tag does not have the conventional format, the value
// returned by Get is unspecified. To determine whether a tag is
// explicitly set to the empty string, use [StructTag.Lookup].
func (tag StructTag) Get(key string) string {
 v, _ := tag.Lookup(key)
 return v
}

// Lookup returns the value associated with key in the tag string.
// If the key is present in the tag the value (which may be empty)
// is returned. Otherwise the returned value will be the empty string.
// The ok return value reports whether the value was explicitly set in
// the tag string. If the tag does not have the conventional format,
// the value returned by Lookup is unspecified.
func (tag StructTag) Lookup(key string) (value string, ok bool) {
 // When modifying this code, also update the validateStructTag code
 // in cmd/vet/structtag.go.

 for tag != "" {
  // Skip leading space.
  i := 0
  for i < len(tag) && tag[i] == ' ' {
   i++
  }
  tag = tag[i:]
  if tag == "" {
   break
  }

  // Scan to colon. A space, a quote or a control character is a syntax error.
  // Strictly speaking, control chars include the range [0x7f, 0x9f], not just
  // [0x00, 0x1f], but in practice, we ignore the multi-byte control characters
  // as it is simpler to inspect the tag's bytes than the tag's runes.
  i = 0
  for i < len(tag) && tag[i] > ' ' && tag[i] != ':' && tag[i] != '"' && tag[i] != 0x7f {
   i++
  }
  if i == 0 || i+1 >= len(tag) || tag[i] != ':' || tag[i+1] != '"' {
   break
  }
  name := string(tag[:i])
  tag = tag[i+1:]

  // Scan quoted string to find value.
  i = 1
  for i < len(tag) && tag[i] != '"' {
   if tag[i] == '\\' {
    i++
   }
   i++
  }
  if i >= len(tag) {
   break
  }
  qvalue := string(tag[:i+1])
  tag = tag[i+1:]

  if key == name {
   value, err := strconv.Unquote(qvalue)
   if err != nil {
    break
   }
   return value, true
  }
 }
 return "", false
}

//go:build go1.14
// +build go1.14

package zerorefl

import (
  "reflect"
  "strconv"
  "unsafe"
)

const (
  // abiTypeSize 是 abi.Type 结构体的大小
  // Go1.14+ 中固定为48字节
  abiTypeSize = 48
)

// 空镜像类型：只做类型标注，不用填字段
type rtype struct{}

type structType struct {
  PkgPath Name
  Fields  []structField
}

type structField struct {
  Name   Name
  Typ    *rtype
  Offset uintptr
}

// Name 类型，跟 runtime.Name 一样
//go:linkname Name runtime.Name
type Name struct {
  Bytes *byte
}

// 下面这些方法都是 runtime.Name 的实现
//go:linkname Name_Name runtime.(*Name).Name
//go:inline
func (n *Name) Name() string {
  if n.Bytes == nil {
    return ""
  }
  i, l := n.ReadVarint(1)
  return unsafe.String(n.DataChecked(1+i, "non-empty string"), l)
}

//go:linkname Name_Tag runtime.(*Name).Tag
//go:inline
func (n *Name) Tag() string {
  if !n.HasTag() {
    return ""
  }
  i, l := n.ReadVarint(1)
  i2, l2 := n.ReadVarint(1 + i + l)
  return unsafe.String(n.DataChecked(1+i+l+i2, "non-empty string"), l2)
}

//go:linkname Name_IsExported runtime.(*Name).IsExported
//go:inline
func (n *Name) IsExported() bool {
  return (*n.Bytes)&(1<<0) != 0
}

//go:linkname Name_IsEmbedded runtime.(*Name).IsEmbedded
//go:inline
func (n *Name) IsEmbedded() bool {
  return (*n.Bytes)&(1<<3) != 0
}

//go:linkname Name_HasTag runtime.(*Name).HasTag
//go:inline
func (n *Name) HasTag() bool {
  return (*n.Bytes)&(1<<1) != 0
}

//go:linkname Name_ReadVarint runtime.(*Name).ReadVarint
//go:inline
func (n *Name) ReadVarint(off int) (int, int) {
  v := 0
  for i := 0; ; i++ {
    x := n.DataChecked(off+i, "read varint")
    v += int(x&0x7f) << (7 * i)
    if x&0x80 == 0 {
      return i + 1, v
    }
  }
}

//go:linkname Name_DataChecked runtime.(*Name).DataChecked
//go:inline
func (n *Name) DataChecked(off int, whySafe string) *byte {
  return (*byte)(addChecked(unsafe.Pointer(n.Bytes), uintptr(off), whySafe))
}

func addChecked(p unsafe.Pointer, x uintptr, whySafe string) unsafe.Pointer {
  return unsafe.Pointer(uintptr(p) + x)
}

//go:linkname toType reflect.toType
//go:noescape
func toType(t *rtype) reflect.Type

// GetField 获取结构体字段，不分配切片
//
//go:inline
func GetField(sf *reflect.StructField, st *structType, i int) bool {
  if st == nil || i < 0 || i >= len(st.Fields) {
    return false
  }
  stf := &st.Fields[i]
  sf.Name = stf.Name.Name()
  sf.Type = toType(stf.Typ)
  sf.Offset = stf.Offset
  sf.Anonymous = stf.Name.IsEmbedded()
  if tag := stf.Name.Tag(); tag != "" {
    sf.Tag = reflect.StructTag(tag)
  }
  if !stf.Name.IsExported() {
    sf.PkgPath = st.PkgPath.Name()
  }
  // 注意：这里不设置 sf.Index，避免无意义的切片分配
  return true
}

//go:inline
func TypeFieldLen(st *structType) int {
  return len(st.Fields)
}

// Type2StructType 将 reflect.Type 转换为 structType
// 用固定偏移量直接转，不拷贝
func Type2StructType(t reflect.Type) *structType {
  if t.Kind() != reflect.Struct {
    return nil
  }
  // reflect.Type 是接口，底层存 [类型指针, 数据指针]
  // 数据指针就是 structType 的起始地址
  // 因为 structType 嵌入了 abi.Type，所以要跳过 abi.Type 的大小
  return (*structType)(unsafe.Pointer((*[2]uintptr)(unsafe.Pointer(&t))[1] + abiTypeSize))
}

// RType2Type 将 *rtype 转换为 reflect.Type
//
//go:inline
func RType2Type(t *rtype) reflect.Type {
  return toType(t)
}

// GetTag 零拷贝获取Tag值
// 比 reflect.StructTag.Get 快，避免了字符串拷贝
func GetTag(tag reflect.StructTag, key string) (value string, ok bool) {
  for tag != "" {
    // Skip leading space.
    i := 0
    for i < len(tag) && tag[i] == ' ' {
      i++
    }
    tag = tag[i:]
    if tag == "" {
      break
    }

    // Scan to colon. A space, a quote or a control character is a syntax error.
    i = 0
    for i < len(tag) && tag[i] > ' ' && tag[i] != ':' && tag[i] != '"' && tag[i] != 0x7f {
      i++
    }
    if i == 0 || i+1 >= len(tag) || tag[i] != ':' || tag[i+1] != '"' {
      break
    }
    name := string(tag[:i])
    tag = tag[i+1:]

    // Scan quoted string to find value.
    needUnquote := false
    i = 1
    for i < len(tag) && tag[i] != '"' {
      if tag[i] == '\\' {
        needUnquote = true
        i++
      }
      i++
    }
    if i >= len(tag) {
      break
    }
    tmp := tag[:i+1]
    qvalue := string(tmp)
    tag = tag[i+1:]

    if key == name {
      if needUnquote {
        // 需要转义时，还是得分配新字符串
        value, err := strconv.Unquote(qvalue)
        if err != nil {
          break
        }
        return value, true
      }
      // 不需要转义时，直接返回字符串切片
      // Go的字符串切片是零拷贝的
      return qvalue[1 : len(qvalue)-1], true
    }
  }
  return "", false
}

package main

import (
  "fmt"
  "reflect"
  "zerorefl"
)

type User struct {
  ID   int    `orm:"primaryKey" json:"id"`
  Name string `orm:"varchar(50)" json:"name"`
  Age  int    `json:"age"`
}

func main() {
  t := reflect.TypeOf(User{})

  // 传统方式：会有切片分配和字符串拷贝
  field1, _ := t.Field(0)
  tag1 := field1.Tag.Get("orm")

  // 零拷贝方式：避免无意义的分配
  st := zerorefl.Type2StructType(t)
  if st != nil {
    var field reflect.StructField
    if zerorefl.GetField(&field, st, 0) {
      tag2, _ := zerorefl.GetTag(field.Tag, "orm")
      fmt.Printf("Tag值: %s (零拷贝)\n", tag2)
    }
  }

  fmt.Printf("传统方式Tag值: %s\n", tag1)
}