type mspan struct {
	next *mspan
	prev *mspan
	// next和prev是指定后续和前导的Span。这代表Span的存在形式并非孤立的一个对象，而是一个双向链表。

	nelems uintptr
	//当前Span中存储的对象数量

	startAddr uintptr 
	npages    uintptr 
    //startAddr(页数) 和 npages(起始地址) — 确定该结构体管理的多个页所在的内存，每个页的大小都是 8KB；

	freeindex uintptr
    //freeindex — 扫描页中"空闲对象"的初始索引；
	allocCache uint64
    //allocCache — allocBits 的补码，可以用于快速查找内存中未被使用的内存；

	allocBits  *gcBits
	gcmarkBits *gcBits
    //allocBits 和 gcmarkBits — 分别用于标记内存块的占用和回收情况；

    spanclass spanClass
    // 标识 mspan 等级，包含 class 和 noscan 两部分信息
    // type spanClass uint8
}

type spanClass uint8
// uint8 左 7 位为 mspan 等级，最右一位标识是否为 noscan

func makeSpanClass(sizeclass uint8, noscan bool) spanClass {
    return spanClass(sizeclass<<1) | spanClass(bool2int(noscan))
}
func (sc spanClass) sizeclass() int8 {
    return int8(sc >> 1)
}
func (sc spanClass) noscan() bool {
    return sc&1 != 0
}

type heapArena struct {
    spans [pagesPerArena]*mspan
    // 实现page到mspan的映射
	// const pagesPerArena = 8192

	bitmap [heapArenaBitmapBytes]byte

    pageInUse [pagesPerArena /8]uint8
    pageMarks [pagesPerArena/8]uint8
    pageSpecials [pagesPerArena/8]uint8
    checkmarks *checkmarksMap
    zeroedBase uintptr
}

type mheap struct {
    lock mutex
    // 堆的全局锁

    allspans []*mspan
    // 记录了所有的 mspan. 需要知道，所有 mspan 都是经由 mheap，使用连续空闲页组装生成的

	arenas [1 << arenaL1Bits]*[1 << arenaL2Bits]*heapArena
    // 在linux 64位系统下
    // 每个heapArena管理的64M大小空间
    // 一级数组大小为1
    // 二级数组大小为2^22
    // 因此理论上，Golang堆上限为2^22*64M=256T

    central [numSpanClasses]struct {
        mcentral mcentral
        // 用于内存地址对齐
        pad      [cpu.CacheLinePadSize - unsafe.Sizeof(mcentral{})%cpu.CacheLinePadSize]byte
    }
    // 多个 mcentral，总个数为 spanClass 的个数

//...    
}

type mcentral struct {
    spanclass spanClass
    partial [2]spanSet 
    // 没有空闲对象（已用尽）的mspan列表
    full    [2]spanSet 
	// 有空闲对象（未用尽）的mspan列表
}

type mcache struct{
  //...
  alloc [numSpanclasses]*mspan
  // numSpanClasses =_NumSizeClasses << 1
  // _NumSizeClasses为Span级别的个数是68，那么numSpanClasses的实际值为136

  tiny uintptr
  tinyoffset uintptr
  tinyAllocs uintptr
}

func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
    if size <= maxSmallSize {
    // 小于 32KB 的微、小对象
        if noscan && size < maxTinySize {
        // 微对象（小于16B且无指针）
		// (1) tiny allocator
        } else {
        // 小对象
		// (2) mcache.allocator
   } else {
    // 大对象（大于32KB）
	// (3) large span
   }  
}

func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
    if size <= maxSmallSize {
    // 小于 32KB 的微、小对象
        if noscan && size < maxTinySize {
			// --------------------------------------------------------------------------------------------------
			// 获取mcache的变量tinyoffset，表示Tiny空间空闲的位移
			off := c.tinyoffset
			// 内存对齐
			if size&7 == 0 {  // size 在 (0, 16) 范围，如果低三位是0，则跟8位对齐
				off = alignUp(off, 8)
			} else if goarch.PtrSize == 4 && size == 12 {
				// 地址长度是4，字节数是12，也是跟8位对齐
				off = alignUp(off, 8)
			} else if size&3 == 0 { // size低二位是0，跟4位对齐
				off = alignUp(off, 4)
			} else if size&1 == 0 { // size低一位是0，跟2位对齐
				off = alignUp(off, 2)
			}
			if off+size <= maxTinySize && c.tiny != 0 {
				// 如果对象的大小和off偏移量加起来仍然比16B小，且Tiny空间存在，则当前对象可以从已有的Tiny空间分配
                // 在当前的Tiny空间分配，增加相关变量大小 
				x = unsafe.Pointer(c.tiny + off)
				c.tinyoffset = off + size
				c.tinyAllocs++
				mp.mallocing = 0
				releasem(mp)
				return x    // 分配后直接返回
			}
			// 从当前P的mcache的spanClass为5的mspan中，申请一个新的16B Object的Tiny空间
			span = c.alloc[tinySpanClass]
			v := nextFreeFast(span)
			if v == 0 {
				v, span, shouldhelpgc = c.nextFree(tinySpanClass)
			}
			x = unsafe.Pointer(v)
            // 将申请的16B内存空间置0，16B由两个长度为uint64地址指向
			(*[2]uint64)(x)[0] = 0
			(*[2]uint64)(x)[1] = 0
			// 非竞态下，如果申请的内存块分配了新对象后，剩余的空间比当前tiny所持有的空间少，那么需要进行替换
			if !raceenabled && (size < c.tinyoffset || c.tiny == 0) {
				c.tiny = uintptr(x)
				c.tinyoffset = size
			}
			size = maxTinySize
			// --------------------------------------------------------------------------------------------------
        } else {
        // 小对象
		// (2) mcache.allocator
   } else {
    // 大对象（大于32KB）
	// (3) large span
   }  
}

func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
    if size <= maxSmallSize {
    // 小于 32KB 的微、小对象
        if noscan && size < maxTinySize {
        // 微对象（小于16B且无指针）
		// (1) tiny allocator
        } else {
	      //--------------------------------------------------------------------------------------------------
          //根据对象大小，映射到其所属的 span 的等级(0~66）
          var sizeclass uint8
          if size <= smallSizeMax-8 {
              sizeclass = size_to_class8[divRoundUp(size, smallSizeDiv)]
          } else {
              sizeclass = size_to_class128[divRoundUp(size-smallSizeMax, largeSizeDiv)]
          }        
          size = uintptr(class_to_size[sizeclass])
          //创建spanClass 标识，其中前7位(span 的等级(0~66))，最后一位(标识对象是否是指针，方便后续gc判断是否需要扫描)
          spc := makeSpanClass(sizeclass, noscan) 
          //获取 mcache 中的 span
          span = c.alloc[spc]  
          //从mcache的span中尝试获取空间
          v := nextFreeFast(span)
          if v == 0 {
          //mcache分配空间失败，则通过mheap兜底
             v, span, shouldhelpgc = c.nextFree(spc)
          }     
          // 分配空间
          x = unsafe.Pointer(v)
          // ...
	      // --------------------------------------------------------------------------------------------------
       }  
   } else {
    // 大对象（大于32KB）
	// (3) large span
   }  
}

func nextFreeFast(s *mspan) gclinkptr {
  // 计算s.allocCache从低位起有多少个0
    theBit := sys.Ctz64(s.allocCache) // Is there a free object in the allocCache?
    if theBit < 64 {
        result := s.freeindex + uintptr(theBit)
        if result < s.nelems {
            freeidx := result + 1
            if freeidx%64 == 0 && freeidx != s.nelems {
                return 0
            }
            //更新bitmap、可用的slot索引
            s.allocCache >>= uint(theBit + 1)
            s.freeindex = freeidx
            s.allocCount++
            //返回找到的内存的地址
            return gclinkptr(result*s.elemsize + s.base())
        }
    }
    return 0
}

func (c *mcache) nextFree(spc spanClass) (v gclinkptr, s *mspan, shouldhelpgc bool) {
    //先查找mcache中对应规格的span
    s = c.alloc[spc]
    shouldhelpgc = false
    //在当前span中找到合适的index索引
    freeIndex := s.nextFreeIndex()
    if freeIndex == s.nelems {
        // freeIndex == nelems 时，表示当前span已满
        // 调用refill函数，从 mcentral 中获取可用的span，并替换掉当前 mcache里面的span
		//...
        // 再次到新的span里面查找合适的index
        freeIndex = s.nextFreeIndex()
    }
    //...

    //计算出来 内存地址，并更新span的属性
    v = gclinkptr(freeIndex*s.elemsize + s.base())
    s.allocCount++
	//...

    return
}

func (c *mcache) refill(spc spanClass) {  
    s := c.alloc[spc]
    // ...
    // 从 mcentral 当中获取对应等级的 span
    s = mheap_.central[spc].mcentral.cacheSpan()
    // ...
    // 将新的 span 添加到 mcahe 当中
    c.alloc[spc] = s
}

func (c *mcentral) cacheSpan() *mspan {
    // ...
    var sl sweepLocker    
    // ...
    sl = sweep.active.begin()
    if sl.valid {
        for ; spanBudget >= 0; spanBudget-- {
            s = c.partialUnswept(sg).pop()
            // ...
            if s, ok := sl.tryAcquire(s); ok {
                // ...
                sweep.active.end(sl)
                goto havespan
            }
            
        // 通过 sweepLock，加锁尝试从 mcentral 的非空链表 full 中获取 mspan
        for ; spanBudget >= 0; spanBudget-- {
            s = c.fullUnswept(sg).pop()
           // ...
            if s, ok := sl.tryAcquire(s); ok {
                // ...
                sweep.active.end(sl)
                goto havespan
                }
                // ...
            }
        }
        // ...
    }

    // ...
    // mcentral中也没有可用的mspan了，则需要从mheap中获取，最终会调用mheap_.alloc方法
    s = c.grow()

    // ...
    // 执行到此处时，s 已经指向一个存在 object 空位的 mspan 了
havespan:
    // ...
    return
}

func (c *mcentral) grow() *mspan {
    npages := uintptr(class_to_allocnpages[c.spanclass.sizeclass()])
    size := uintptr(class_to_size[c.spanclass.sizeclass()])

    s := mheap_.alloc(npages, c.spanclass)
    // ...

    // ...
    return s
}

func (h *mheap) alloc(npages uintptr, spanclass spanClass) *mspan {
    var s *mspan
    systemstack(func() {
        // ...
        s = h.allocSpan(npages, spanAllocHeap, spanclass)
    })
    return s
}

func (h *mheap) allocSpan(npages uintptr, typ spanAllocType, spanclass spanClass) (s *mspan) {
    gp := getg()
    base, scav := uintptr(0), uintptr(0)
    
    // 注意此处存在从每个P的页缓存pageCache中获取空闲页组装mspan
    
    // 加上堆全局锁
    lock(&h.lock)
    if base == 0 {
        // 通过基数树索引快速寻找满足条件的连续空闲页
        base, scav = h.pages.alloc(npages)
        // ...
    }
    
    // ...
    unlock(&h.lock)
HaveSpan:
    // 把空闲页组装成 mspan
    s.init(base, npages)
    
    // 将这批页添加到 heapArena 中，建立由页指向 mspan 的映射
    h.setSpans(s.base(), npages, s)
    // ...
    return s
}

func findObject(p, refBase, refOff uintptr) (base uintptr, s *mspan, objIndex uintptr) {
    s = spanOf(p)
    // ...
    return
}
  func spanOf(p uintptr) *mspan {
      // 计算对象所在的 arena 索引
      ri := arenaIndex(p)
      // 从全局 mheap 中获取该 arena
      l2 := mheap_.arenas[ri.l1()]
      // 获取该 arena 中的具体 heapArena
      ha := l2[ri.l2()]
      // 从 heapArena 中的 spans 数组中获取具体的 mspan
      return ha.spans[(p/pageSize)%pagesPerArena]
  }

// https://github.com/golang/go/blob/41d8e61a6b9d8f9db912626eb2bbc535e929fefc/src/runtime/runtime2.go#L576

type p struct {
	id          int32
	status      uint32 // one of pidle/prunning/...
	link        puintptr
	schedtick   uint32     // incremented on every scheduler call
	syscalltick uint32     // incremented on every system call
	sysmontick  sysmontick // last tick observed by sysmon
	m           muintptr   // back-link to associated m (nil if idle)
	mcache      *mcache
	pcache      pageCache
	raceprocctx uintptr

// nextFreeFast returns the next free object if one is quickly available.
// Otherwise it returns 0.
func nextFreeFast(s *mspan) gclinkptr {
	theBit := sys.Ctz64(s.allocCache) // Is there a free object in the allocCache?
	if theBit < 64 {
		result := s.freeindex + uintptr(theBit)
		if result < s.nelems {
			freeidx := result + 1
			if freeidx%64 == 0 && freeidx != s.nelems {
				return 0
			}
			s.allocCache >>= uint(theBit + 1)
			s.freeindex = freeidx
			s.allocCount++
			return gclinkptr(result*s.elemsize + s.base())
		}
	}
	return 0
}

#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <unistd.h>

#define handle_error(msg) \
    do { perror(msg); exit(EXIT_FAILURE); } while (0)

int
main(int argc, char *argv[])
{
    int          fd;
    char         *addr;
    off_t        offset, pa_offset;
    size_t       length;
    ssize_t      s;
    struct stat  sb;

    if (argc < 3 || argc > 4) {
        fprintf(stderr, "%s file offset [length]\n", argv[0]);
        exit(EXIT_FAILURE);
    }

    fd = open(argv[1], O_RDONLY);
    if (fd == -1)
        handle_error("open");

    if (fstat(fd, &sb) == -1)           /* To obtain file size */
        handle_error("fstat");

    offset = atoi(argv[2]);
    pa_offset = offset & ~(sysconf(_SC_PAGE_SIZE) - 1);
        /* offset for mmap() must be page aligned */

    if (offset >= sb.st_size) {
        fprintf(stderr, "offset is past end of file\n");
        exit(EXIT_FAILURE);
    }

    if (argc == 4) {
        length = atoi(argv[3]);
        if (offset + length > sb.st_size)
            length = sb.st_size - offset;
                /* Can't display bytes past end of file */

    } else {    /* No length arg ==> display to end of file */
        length = sb.st_size - offset;
    }

    addr = mmap(NULL, length + offset - pa_offset, PROT_READ,
                MAP_PRIVATE, fd, pa_offset);
    if (addr == MAP_FAILED)
        handle_error("mmap");

    s = write(STDOUT_FILENO, addr + offset - pa_offset, length);
    if (s != length) {
        if (s == -1)
            handle_error("write");

        fprintf(stderr, "partial write");
        exit(EXIT_FAILURE);
    }

    munmap(addr, length + offset - pa_offset);
    close(fd);

    exit(EXIT_SUCCESS);
}



#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <unistd.h>

#define handle_error(msg) \
    do { perror(msg); exit(EXIT_FAILURE); } while (0)

int
main(int argc, char *argv[])
{
    char *v=0x7f216f308000;
	int n = 20
	p := mmap(v, n, PROT_NONE, MAP_ANON|MAP_PRIVATE, -1, 0)
    if (p == MAP_FAILED)
        handle_error("mmap");


    munmap(addr, 20);

    exit(EXIT_SUCCESS);
}