iMIKI.moe

值接收器和指针接收器

Wed, 27 Nov 2024 00:00:00 GMT

值接收器和指针接收器

你这 interface 怎么看都有问题

场景

有这样一个结构体，包含一个整数字段、2个指针接收器和2个值接收器：

type s struct {
	v int
}

func (t *s) fn1() {
	t.v = 1
}

func (t *s) fn2() {
	t.v = 2
}

func (t s) fn3() {
	t.v = 3
}

func (t s) fn4() {
	t.v = 4
}

现在尝试将这个结构体和他的指针转换到以下3种interface

Scene 1

type i1 interface {
	fn1()
	fn2()
}
var a i1 = s{v: 0} // not OK
var a i1 = &s{v: 0} // OK

Scene 2

type i2 interface {
	fn1()
	fn3()
}

var a i2 = s{v: 0} // not OK
var a i2 = &s{v: 0} // OK

Scene 3

type i3 interface {
	fn3()
	fn4()
}

var a i3 = s{v: 0} // OK
var a i3 = &s{v: 0} // OK

根据上面场景，可以发现：

接收器1	接收器2	调用者	有效
指针	指针	值	否
指针	指针	指针	是
值	指针	值	否
值	指针	指针	是
值	值	值	是
值	值	指针	是

看起来就像是：

调用者是指针，实现接口时，值接收器会被当作有效的实现；

调用者是值，实现接口时指针接收器不会被当作有效的实现。

原因

首先我们简化一下结构体方便我们观察：

type s2 struct {
	v int
}

//go:noinline
func (t *s) fn1() { // 这个是个指针接收器
	t.v = 1
}

//go:noinline
func (t s) fn2() { // 这个是个值接收器
	t.v = 2
}

使用go tool compile -S ./main.go将代码转换为plan9汇编，我们可以看到go编译器生成了3个函数（不是2个也不是4个）：

// func (t *s) fn1()
TEXT    main.(*s2).fn1(SB), NOSPLIT|NOFRAME|ABIInternal, $0-8
...

// func (t s) fn2()
TEXT    main.s2.fn2(SB), NOSPLIT|NOFRAME|ABIInternal, $0-8
...

// 编译器确实生成了一个 func (t *s) fn2()
TEXT    main.(*s2).fn2(SB), DUPOK|WRAPPER|ABIInternal, $24-8
...

所以根本的原因是：

值接收器会自动生成一个指针接收器，指针接收器不会生成值接收器

所以无论interface的实现函数是指针还是值接收器，只要我们无脑使用结构体的指针，就一定能达到我们想要的效果了......吗？

那肯定是不行的，毕竟IDE都会告诉我们：

Goland:

Struct s2 has methods on both value and pointer receivers. Such usage is not recommended by the Go Documentation.

那么这两种使用到底有什么不一样呢？

依然是使用这个简化的结构体：

type s2 struct {
	v int
}

//go:noinline
func (t *s2) fn1() { // 这个是个指针接收器
	t.v = 1
}

//go:noinline
func (t s2) fn2() { // 这个是个值接收器
	t.v = 2
}

再次使用go tool compile -S ./main.go将代码转换为plan9汇编，然后我们再一个一个的观察

编译后的函数

func (t *s) fn1()

0x0000 00000    TEXT    main.(*s2).fn1(SB), NOSPLIT|NOFRAME|ABIInternal, $0-8
0x0000 00000    MOVQ    AX, main.t+8(SP)     // *t 拷贝到栈
0x0005 00005    TESTB   AL, (AX)             // 检查低位是否为 0
0x0007 00007    MOVQ    $1, (AX)             // t.v = 1
0x000e 00014    RET

这里的 AX 内是一个指针，可以看到，第二个 MOVQ 修改的是 AX 指向的值，所以修改会导致原本在 AX 中的值变化

func (t s) fn2()

0x0000 00000    TEXT    main.s2.fn2(SB), NOSPLIT|NOFRAME|ABIInternal, $0-8
0x0000 00000    MOVQ    AX, main.t+8(SP)    // t 拷贝到栈
0x0005 00005    MOVQ    $2, main.t+8(SP)    // 为栈中的 t.v 赋值2
0x000e 00014    RET

这里的 AX 内是一个结构体（这段代码里面实际是一个 int），这里的第二个 MOVQ 修改的是 AX 拷贝到函数栈中的值，函数结束时就会被删除，所以不会导致 AX 中的值产生变化

func (t *s) fn2()

从上面我们知道，这个func (t *s) fn2()是编译器自己生成出来的，但是他的函数内容确实和前面...可以说完全不一样，将其中进行栈伸缩和异常检查的代码去掉后，得到一份精简后的代码

0x0000 00000    TEXT    main.(*s2).fn2(SB), DUPOK|WRAPPER|ABIInternal, $24-8
0x0006 00006    PUSHQ   BP
0x0007 00007    MOVQ    SP, BP
0x000a 00010    SUBQ    $16, SP                   // 准备2字节的栈空间
0x000e 00014    MOVQ    32(R14), R12
0x0017 00023    MOVQ    AX, main.t+32(SP)         // 从AX读取参数 *t
0x0027 00039    TESTB   AL, (AX)
0x0029 00041    MOVQ    (AX), AX                  // 获取 *t 指向的值
0x002c 00044    MOVQ    AX, main..autotmp_1+8(SP) // 拷贝到栈空间
0x0031 00049    CALL    main.s2.fn2(SB)           // 调用真实的函数
0x0036 00054    ADDQ    $16, SP
0x003a 00058    POPQ    BP
0x003b 00059    RET

在这个函数中，第四个 MOVQ 将原本 AX 中的指针变成了函数栈中的值，然后由 CALL 传给了真正的 main.s2.fn2(SB)，所以这个中间函数实际上就是负责制造一个指针指向的值的拷贝。

翻译成go，其实就是很简单一句：

func (s *s2) fn2() {
  return (*s).fn2()
}

函数的使用

现在我们使用一个main函数来使用它的method

func main () {
	t1 := &s2{}
	t1.fn1()
	t1.fn2()
	t2 := s2{}
	t2.fn1()
	t2.fn2()
}

同样，将代码转换为plan9汇编，并将其中进行栈伸缩和异常检查的代码去掉后，得到一份精简后的代码

0x0000 00000    TEXT    main.main(SB), ABIInternal, $56-0
0x0006 00006    PUSHQ   BP
0x0007 00007    MOVQ    SP, BP
0x000a 00010    SUBQ    $48, SP
// 初始化第一个 s2{}
0x000e 00014    MOVQ    $0, main..autotmp_3+24(SP)
// t1.fn1()
0x0017 00023    LEAQ    main..autotmp_3+24(SP), AX // 获取第一个 s2{} 的地址到 AX 中
0x001c 00028    MOVQ    AX, main..autotmp_2+40(SP)
0x0021 00033    TESTB   AL, (AX)
0x0023 00035    MOVQ    $0, (AX)                   // 再次赋值0（？）
0x002a 00042    MOVQ    AX, main.t1+32(SP)         // 保存 AX 内容到栈上
0x002f 00047    CALL    main.(*s2).fn1(SB)         // 调用函数
// t1.fn2()
0x0034 00052    MOVQ    main.t1+32(SP), CX         // 取出刚刚的 AX
0x0039 00057    TESTB   AL, (CX)
0x003b 00059    MOVQ    (CX), AX                   // 取出 *t 指向的内容
0x003e 00062    MOVQ    AX, main..autotmp_4+16(SP) // 保存 AX 内容到栈上
0x0043 00067    CALL    main.s2.fn2(SB)            // 调用函数
// 初始化第二个 s2{}
0x0048 00072    MOVQ    $0, main.t2+8(SP)
// t2.fn1()
0x0051 00081    LEAQ    main.t2+8(SP), AX          // 获取第二个 s2{} 的地址到 AX 中
0x0056 00086    CALL    main.(*s2).fn1(SB)         // 调用函数
// t2.fn2()
0x005b 00091    MOVQ    main.t2+8(SP), AX          // 获取第二个 s2{} 的值到 AX 中
0x0060 00096    CALL    main.s2.fn2(SB)            // 调用函数

0x0065 00101    ADDQ    $48, SP
0x0069 00105    POPQ    BP
0x006a 00106    RET

所以上面原本的代码翻译一下就是：

func main () {
	t1 := &s2{}
	t1.fn1()
	(*t1).fn2()
	t2 := s2{}
	(&t2).fn1()
	t2.fn2()
}

Deep Copy

Mon, 24 Jun 2024 00:00:00 GMT

Deep Copy

为解决循环指针而设计的深度拷贝，目前 chan/map/func 还没有实现。

源码

package main

import (
	"reflect"
)

func DeepCopy[T any](src, dst *T) {
	srv := reflect.ValueOf(src)
	srv = srv.Elem()
	drv := reflect.ValueOf(dst)
	drv = drv.Elem()
	addrMap := map[uint64]reflect.Value{}
	handleStruct(srv, drv, addrMap)
}

func genKey(src reflect.Value) uint64 {
	switch src.Kind() {
	case reflect.Pointer, reflect.Chan, reflect.Map, reflect.UnsafePointer, reflect.Func, reflect.Slice:
		return uint64(src.Pointer())<<6 + uint64(src.Kind())<<1
	default:
		return uint64(src.UnsafeAddr())<<6 + uint64(src.Kind())<<1 + 1
	}
}

func handlePointer(src, dst reflect.Value, addrMap map[uint64]reflect.Value) {
	src = src.Elem()
	addr := genKey(src)
	ndst, ok := addrMap[addr]
	if !ok {
		ndst = reflect.New(src.Type()).Elem()
		addrMap[addr] = ndst
		switch src.Kind() {
		case reflect.Struct:
			handleStruct(src, ndst, addrMap)
		case reflect.Interface:
			handleInterface(src, ndst, addrMap)
		case reflect.Pointer:
			handlePointer(src, ndst, addrMap)
		case reflect.Array:
			handleArray(src, ndst, addrMap)
		case reflect.Slice:
			handleSlice(src, ndst, addrMap)
		case reflect.Chan:
		case reflect.Func:
		case reflect.Map:
		default:
			ndst.Set(src)
		}
	}
	dst.Set(ndst.Addr())
}

func handleStruct(src, dst reflect.Value, addrMap map[uint64]reflect.Value) {
	addrMap[genKey(src)] = dst
	for i := 0; i < src.NumField(); i++ {
		srcf := src.Field(i)
		addr := genKey(srcf)
		dstf, ok := addrMap[addr]
		if !ok {
			ndstf := dst.Field(i)
			addrMap[addr] = ndstf
			switch srcf.Kind() {
			case reflect.Struct:
				handleStruct(srcf, ndstf, addrMap)
			case reflect.Interface:
				handleInterface(srcf, ndstf, addrMap)
			case reflect.Pointer:
				handlePointer(srcf, ndstf, addrMap)
			case reflect.Array:
				handleArray(srcf, ndstf, addrMap)
			case reflect.Slice:
				handleSlice(srcf, ndstf, addrMap)
			case reflect.Chan:
			case reflect.Func:
			case reflect.Map:
			default:
				ndstf.Set(srcf)
			}
		} else {
			dst.Field(i).Set(dstf)
		}
	}
}

func handleInterface(src, dst reflect.Value, addrMap map[uint64]reflect.Value) {
	src = src.Elem()
	switch src.Kind() {
	case reflect.Struct:
		handleStruct(src, dst, addrMap)
	case reflect.Interface:
		handleInterface(src, dst, addrMap)
	case reflect.Pointer:
		handlePointer(src, dst, addrMap)
	case reflect.Array:
		handleArray(src, dst, addrMap)
	case reflect.Slice:
		handleSlice(src, dst, addrMap)
	case reflect.Chan:
	case reflect.Func:
	case reflect.Map:
	default:
		dst.Set(src)
	}
}

func handleArray(src, dst reflect.Value, addrMap map[uint64]reflect.Value) {
	for i := 0; i < src.Len(); i++ {
		srcf := src.Index(i)
		addr := genKey(srcf)
		dstf, ok := addrMap[addr]
		if !ok {
			ndstf := dst.Index(i)
			addrMap[addr] = ndstf
			switch srcf.Kind() {
			case reflect.Struct:
				handleStruct(srcf, ndstf, addrMap)
			case reflect.Interface:
				handleInterface(srcf, ndstf, addrMap)
			case reflect.Pointer:
				handlePointer(srcf, ndstf, addrMap)
			case reflect.Array:
				handleArray(srcf, ndstf, addrMap)
			case reflect.Slice:
				handleSlice(srcf, ndstf, addrMap)
			case reflect.Chan:
			case reflect.Func:
			case reflect.Map:
			default:
				ndstf.Set(srcf)
			}
		} else {
			dst.Index(i).Set(dstf)
		}
	}
}

func handleSlice(src, dst reflect.Value, addrMap map[uint64]reflect.Value) {
	addrMap[genKey(src)] = dst
	dst.Grow(src.Len() - dst.Len())
	dst.SetLen(src.Len())
	for i := 0; i < src.Len(); i++ {
		srcf := src.Index(i)
		addr := genKey(srcf)
		dstf, ok := addrMap[addr]
		if !ok {
			ndstf := dst.Index(i)
			addrMap[addr] = ndstf
			switch srcf.Kind() {
			case reflect.Struct:
				handleStruct(srcf, ndstf, addrMap)
			case reflect.Interface:
				handleInterface(srcf, ndstf, addrMap)
			case reflect.Pointer:
				handlePointer(srcf, ndstf, addrMap)
			case reflect.Array:
				handleArray(srcf, ndstf, addrMap)
			case reflect.Slice:
				handleSlice(srcf, ndstf, addrMap)
			case reflect.Chan:
			case reflect.Func:
			case reflect.Map:
			default:
				ndstf.Set(srcf)
			}
		} else {
			dst.Index(i).Set(dstf)
		}
	}
}

LMDB - 低gc压力缓存

Mon, 24 Jun 2024 00:00:00 GMT

LMDB - 低gc压力缓存

在Golang中创建一个缓存库最头痛的问题就是gc，大家也集思广益地想出了各种避免的办法，今天看到了一个比较巧妙的思想，就想要实现一下试试看。

原理

Golang中的保存一个变量，第一个的想法都是直接new一个，然后将地址保存在内存中的map里面，这样的问题就是gc每次都会去扫描map中的指针指向的值，在map中东西特别多的时候，gc效率将会严重下降。

这个方法的实现中，我也是简单的将指针保存在map中，不一样的是，指针不是new出来的，而是变量的地址。这个方法中，向Set一个变量而不是指针，然后将变量复制到lmdb中的数组里，然后取出其在数组中的变量的地址，再放入map中保存，后续使用时就直接从map中取出这个指针就行。

由于每个指针指向的值实际上保留在数组中，gc扫描将不会去检查指针指向的值，又因为指针本身实际是简单的uintptr，整个map将直接不被扫描，效率将大大提高

实例源代码

package lmdb

const defaultFragmentCount = 128
const fragmentSize = 128

type LMDBIndex struct {
	Fragment uint
	Index    uint
}

type Item[T any] struct {
	realItem T
	deleted  bool
}

type Items[T any] struct {
	items        []Item[T]
	deletedCount uint
}

type LMDB[K comparable, V any] struct {
	length  uint
	m       map[K]LMDBIndex
	storage []Items[V]
}

func NewLMDB[K comparable, V any]() *LMDB[K, V] {
	return &LMDB[K, V]{
		length:  0,
		m:       make(map[K]LMDBIndex),
		storage: make([]Items[V], 0, defaultFragmentCount),
	}
}

func (m *LMDB[K, V]) Get(key K) (*V, bool) {
	index, ok := m.m[key]
	if !ok {
		return nil, false
	}

	t := m.storage[index.Fragment].items[index.Index]
	return &t.realItem, true
}

func (m *LMDB[K, V]) getNextIndex() LMDBIndex {
	for fi, fragment := range m.storage {
		if fragment.deletedCount == 0 {
			continue
		}

		for ii := range fragmentSize {
			if ii >= len(fragment.items) {
				fragment.items = append(fragment.items, Item[V]{deleted: true})
				m.storage[fi] = fragment
				return LMDBIndex{
					Fragment: uint(fi),
					Index:    uint(ii - 1),
				}
			}
			item := fragment.items[ii]
			if !item.deleted {
				continue
			}
			return LMDBIndex{
				Fragment: uint(fi),
				Index:    uint(ii - 1),
			}
		}
	}

	m.storage = append(m.storage, Items[V]{
		items:        make([]Item[V], 1, fragmentSize),
		deletedCount: fragmentSize,
	})

	return LMDBIndex{
		Fragment: uint(len(m.storage) - 1),
		Index:    0,
	}
}

func (m *LMDB[K, V]) Set(key K, value V) {
	index, ok := m.m[key]
	if ok {
		m.storage[index.Fragment].items[index.Index] = Item[V]{
			realItem: value,
			deleted:  false,
		}
	} else {
		index = m.getNextIndex()
		m.m[key] = index
		fragment := m.storage[index.Fragment]
		fragment.items[index.Index] = Item[V]{
			realItem: value,
			deleted:  false,
		}
		m.storage[index.Fragment] = fragment
	}
	m.length++
}

func (m *LMDB[K, V]) Delete(key K) {
	index, ok := m.m[key]
	if !ok {
		return
	}
	fragment := m.storage[index.Fragment]
	fragment.items[index.Index] = Item[V]{
		deleted: true,
	}
	fragment.deletedCount++
	m.storage[index.Fragment] = fragment
	m.length--
	delete(m.m, key)
}

func (m *LMDB[K, V]) Len() uint {
	return m.length
}

type TestStruct struct {
	Str string
	Num int
}