noname

package main

import (
    "fmt"
    "sync"
    "time"
)

type Singleton struct {
    data string
}

var instance *Singleton
var once sync.Once

func GetInstance() *Singleton {
    once.Do(func() {
        fmt.Println("Creating Singleton instance")
        instance = &Singleton{data: "I'm the only one!"}
    })
    return instance
}

func main() {
    for i := 0; i < 5; i++ {
        go func() {
            fmt.Printf("%p\n", GetInstance())
        }()
    }

    // Wait for goroutines to finish
    time.Sleep(3 * time.Second)
}

// table-groups是二维数组，算上slot的话是三维
// 
// map_header -> table1 -> group1(8个slot)
//                      -> group2
//                      ...
//                      -> group127
// 
//            -> table2
//            -> ...
//            -> tableN
//
// 当hint<=8时，map_header直接指向一个group，全量扫描操作
// 当hint>8 and hint<=1024*7/8时，一个table，2~128个group
// 当hint>1024*7/8时，多个table，多个group
// 
// hash高B位 - 用于定位table
// h1-hash高57位 - 用于定位group
// h2-hash低7位 - 用于匹配hash，类似tophash

// src/internal/runtime/maps/map.go
type Map struct {
    used uint64            // 已用slot，当数据量<=8时用来替换table的used使用
    seed uintptr           // 哈希函数种子
    dirPtr unsafe.Pointer  // table数组指针/group指针
    dirLen int             // table数组大小
    globalDepth uint8      // log2(dirLen)（相当于旧版的B）
    globalShift uint8      // 64-globalDepth，高B位用做table的索引
    writing uint8          // 是否正在写入，乐观锁
    clearSeq uint64        // 执行过多少次clear，扩容时，获取数据判断用
}

// src/internal/runtime/maps/table.go
type table struct {
    used uint16            // 已用slot，最多能写入1024*7/8=896个slot
    capacity uint16        // slot容量 <=1024（由hint算出，2的乘方向上取整）
    growthLeft uint16      // 可用slot，与used相反，初始值最大为896
    localDepth uint8       // >globalDepth？分裂/遍历时使用
    index int              // 上层directory数组中的index（-1-过期，作用类似localDepth）
    groups groupsReference // group数组，8个slot为一组，最多1024/8=128组
}

// src/internal/runtime/maps/group.go
type groupsReference struct {
    data unsafe.Pointer    // group数组，8个slot为一组，具体结构看下方
    lengthMask uint64      // 长度固定为2^N，因此mask=2^N-1
}

type groupReference struct {
    // 结构如下
    //
    // type group struct {
    //     ctrls ctrlGroup                    // 8个8bit的ctrl，共三种状态
    //     slots [abi.SwissMapGroupSlots]slot // 8个slot(key/value对)
    // }
    // 
    // 三种状态如下：
    //      empty: 1 0 0 0 0 0 0 0
    //    deleted: 1 1 1 1 1 1 1 0
    //       full: 0 h h h h h h h  // h represents the H2 hash bits
    //
    // type slot struct {
    //     key  typ.Key  // 键
    //     elem typ.Elem // 值
    // }
    data unsafe.Pointer // ctrls数组+slots数组
    // 内存布局如下（C语言开发者真的很喜欢这种内存布局啊）
    // | ctrls         | slots         |
    // |ctrl7|...|ctrl0|slot0|...|slot7|
}

// 
// hmap -> oldbuckets
//      -> buckets         -> bmap0(8个key/value对) 
//                         -> bmap1 -> overflow0(bmapX) -> overflow1(bmapZ)
//                         -> ...  
//                         -> bmapM -> overflow0(bmapY)
//                         -> bmapN
//
//      -> extra.overflow  -> bmapX(pre-alloc)
//                         -> bmapY(pre-alloc)
//                         -> ...
//                         -> bmapZ(new-alloc)
// 

// src/runtime/map.go
type hmap struct {
    count     int              // 元素数量-key/value对
    flags     uint8            // 1-iter正在使用buckets字段 2-iter正在使用oldbuckets字段 4-正在写入 8-同等大小扩容
    B         uint8            // buckets数量=(loadFactor * 2^B)
    noverflow uint16           // 统计溢出buckets的数量，当B大于15时不是精确值
    hash0     uint32           // 哈希种子，计算hash用
    buckets    unsafe.Pointer  // buckets数组
    oldbuckets unsafe.Pointer  // 旧buckets数组，扩容时用
    nevacuate  uintptr         // 下一个未疏散的bucket索引
    clearSeq   uint64          // 执行过多少次clear
    extra *mapextra            // 可选字段，不是每个map都需要，同时也需要为gc考虑
}

// key/value都不是指针才会使用下面几个字段
type mapextra struct {
    overflow    *[]*bmap       // 溢出buckets，buckets链接使用
    oldoverflow *[]*bmap       // 溢出buckets，oldbuckets链接使用，扩容时
    nextOverflow *bmap         // 下一个可用/未使用overflow的索引
}

// bucket结构，可存储8个key/value对及其他数据，编译时自动补充其余结构，真实结构如下
//    A "bucket" is a "struct" {
//          tophash [abi.MapBucketCount]uint8  // hash的高8位
//          keys [abi.MapBucketCount]keyType   // 所有key
//          elems [abi.MapBucketCount]elemType // 所有value
//          overflow *bucket // 下一个溢出桶指针
//        }
// 详细可见MapBucketType函数（src/cmd/compile/internal/reflectdata/reflect.go）
type bmap struct {
    // abi.MapBucketCount=8
    // 0-默认状态 1-已删除 2-疏散到x 3-疏散到y 4-不需要疏散 5-guard xyz(>5)-正常tophash值
    // 状态转移如下：
    // 0/xyz -> 2/3/4 => 如果所有bucket都疏散完毕，会一次性清空释放
    // 0/xyz -> 1 删除 => 如果idx+1的状态是0，则向前寻找状态为1数据并改为0
    tophash [abi.MapBucketCount]uint8
}

// src/runtime/slice.go
type slice struct {
    array unsafe.Pointer
    len   int
    cap   int
}

// len=3 cap=3
var v1 = []int{1, 2, 3}
// len=10 cap=10
var v2 = make([]int, 10) // var v2 = make([]int, 0, 10)
// len=4 cap=9
var v3 = v2[1:5]