Damao

打造自己专属的开发环境

2023-08-27T09:21:00+00:00

目标🎯

使用VIM进行所有文本编辑(心中有剑)
开始拥有一套专属定制终端开发环境

挑选shell

⌨️

oh-my-zsh

很多漂亮的主题
丰富的插件

插件

autojump
zsh-autosuggestions
zsh-syntax-highlighting
各种命令工具的插件

fish

挑选终端复用器

守护天使👼

什么是终端复用器?

使用ssh登陆后, sshd会派生出一个shell进程, 用户通过和这个shell进程交互执行程序命令.

用户执行的程序命令一般都是当前shell进程的子进程, ssh连接断了之后,当时执行的程序都会退出.

tmux

https://github.com/tmux/tmux/wiki/Getting-Started

sessions

| 命令 | 功能 | | ———– | —————————— | | tmux | 启动tmux/创建默认session | | tmux attach | 进入之前的工作环境/默认session |

panes

prefix key 默认 ctrl + b

命令	功能
prefix key + %	左右分屏
prefix key + “	上下分屏
prefix key + ⬆️⬇️⬅️➡️	分屏间移动

windows

Zellij

https://zellij.dev

挑选编辑器

![[Pasted image 20230815173539.png]]

emacs

神的编辑器

伪装成编辑器的操作系统

vim

编辑器之神

long live interface

编辑器来来往往, vim接口永存

手中无剑心中有剑🗡️

emacs evil mode
IdeaVim
VSCodeVim

搞什么 keones copilot,应该搞一个vim 比赛，传统组对vim 组起码提高30%编码效率

开始动手吧

准备工作🔨

一台服务器作为开发机

配置: 公司的开发机就ok (2C8G)

不动手应该就是看个热闹

dotfiles

sh -c "$(curl -fsLS git.io/chezmoi)" -- init --apply yedamao

一键部署脚本

sh -c "$(curl -fsSL https://raw.githubusercontent.com/yedamao/installer/main/installer.sh)"

vimtutor

梦开始的地方 ☁️

Vimtutor 十年前最超值的30min时间投资

Let’s do this

好东西

vim-slime

reference

tmux使用教程
vim-slime
chapter 9.9 shell执行程序

B+树与数据库索引

2023-05-31T18:14:00+00:00

曾经我有很多疑惑?

为啥表一般都有一个自增ID?

索引是什么?联合索引又是什么?

为什么要分表?这怎么上来就分100张啊

为什么删除数据磁盘空间也不会释放?

DBA让我回收碎片空间, 这咋回收呀?

答案都在b+树，把b+树和我们日常的数据库操作联系起来，就有一种一通百通的感觉

B+树

内存

随机读写

数组
哈希表
链表（跳表)
二叉树(AVL/红黑树…)

完全可以用内存实现一个关系数据库, 但是内存太贵了

磁盘

讲究一个量大管饱读写数据需要先寻道,再按数据块(页)整体读取或写入.

闪存(SSD)

比磁盘快一个数量级

按数据块(页)整体读取或写入

B+树的目标: 充分利用磁盘读写数据块 ,减少磁盘IO操作.

B树 Familly

B Tree (1971)
B+ Tree (1973)
B link Tree (1981)

B+树

B+树是一个保持数据有序的绝对平衡的树形数据结构.

查找/顺序遍历/插入/删除都是 O(logN).

类似二叉树,但是一个节点可以有多个子节点
专为读写块数据优化

B+树的属性

M路的搜索树

绝对平衡 (所有的叶子节点都在一层)
除了根节点,其他节点全部至少半满 M/2-1 ≤ #keys ≤ M-1
每一个有k个key的内部节点都会有k+1个子节点

Example:

B+树节点

每个节点都由 key/value pair的数组组成

key就是索引字段的属性值
value 内部节点和叶子节点不同

数组通常使用key进行排序

B+树叶子节点

叶子节点的值

在线演示

Innodb和B+树

聚簇索引(Clustered indexes)

id	col
1	A
2	B
3	C
4	D

用来组织存储数据
表中的记录按照聚簇索引列顺序存储
通常主键就是聚簇索引
如果没有主键,INNODB用第一个唯一索引作为聚簇索引
如果没有主键也没有合适的唯一索引, INNODB生成一个一个row_id，作为隐藏的聚簇索引, 业务查询无法使用
自增ID是不错的选择

聚簇索引加速查询

可以直接定位到包含行数据的页, 不需要再读取额外的页
使用聚簇索引遍历数据或者 order by

二级索引(Secondary indexes)

除了用来组织表数据的聚簇索引外的其他索引，统称为二级索引.

INNODB中二级索引存储的值是聚簇索引的key

联合索引(Multiple-Column Indexes)

同时使用多个字段作为索引.

mysql最多可以使用16个字段, 某些字段可以只取一部分前缀
可以使用联合索引查找符合所有索引字段的数据,或者符合第一个索引字段,或者前两个索引字段,或者前三个等等..
所以定义联合索引的先后顺序非常重要. 一个合适的联合索引可以加速多种查询场景

其他

分表

降低B+树高度,提高查询速度

$H = logM^N$

M 每个页可以存的数据行数

N 总数据量

以IM消息库为例:

page size 16k, . M = 100

分表 100张 - 每张表数据量约 3千万

H = log 100 ^ 30000000 = 6.2 约等于 3.7

如果不分表单表数据量 30亿

H = log 100 ^ 3000000000 = 7.87 约等于 4.7

碎片整理

二级索引随机的数据插入或者删除都会导致索引数据碎片.

物理页的顺序和索引实际的顺序可能差的太多
页内存在很多没有使用的空间

ALTER TABLE tbl_name ENGINE=INNODB

对表进行重建

释放磁盘空间
重新按顺序组织索引数据在磁盘上分布

参考

Go运行时network poller实现

2021-12-31T09:21:00+00:00

network poller 是个啥?

先从实现一个telnet程序开始，回顾一下unix下的五种IO模型.

实现telnet

telnet命令从终端读取命令写入网络连接,再从网络连接读取执行结果写回终端. 远端的telnetd程序读取输入的命令,在shell中进行执行,把执行命令产生的输出结果返回给用户.

blocking

如果我们只需要处理一个文件描述符, 一个循环搞定.

while ((n = read(STDIN_FILENO, buf, BUFSIZ)) > 0)
                  if (write(STDOUT_FILENO, buf, n) != n)
                      err_sys("write error");

但是我们的telnet程序需要同时处理两个文件描述符, 怎么办?

并发方案开始登场啦

父子进程, 父进程负责从终端读取然后写入网络连接, 子进程负责从网络连接读取让后写入终端. 还需要处理两个父子进程之间的通信. 还可以在一个进程中使用两个线程, 但是需要处理两个线程数据的同步问题.

nonblocking

使用非阻塞的方案, 把两个文件描述符都设置成非阻塞的.

for (;;) {
	
	if 尝试从stdin读取命令; 读到数据 {
		处理数据写入,网络连接
	} else if 出错 {
	} else {
		// EWOULDBLOCK 暂时没数据
	}
	
	if 尝试从网络连接读取; 读到数据 {
		处理数据写入stdout
	} else if 出错 {
	} else {
		// EWOULDBLOCK 暂时没数据
	}

	sleep 一会儿
}

This type of loop is called polling.

这种方法的缺点, sleep 时间太小浪费cpu，sleep时间太长不够及时.

I/O multiplexing

一种更好的方案, IO多路复用. 我们把所有自己关心的文件描述符放在一起,然后调用某个函数, 当有一个或者一批文件描述可以写或者读数据了, 调用返回, 通知程序哪些文件描述符可写或者可读.

fds = {terminalfd, netconn}
for (;;) {
	readyfds = system_call(fds)
	
	// 遍历可以处理的文件描述符进行处理
	for fd = range readyfds {
		// do something
	}
}

IO多路复用的实现有很多, unix系统都支持（好像是） select/pselect/poll. 各个分支系统都有自己更高性能的方法. 比如 Linux epoll, BSD系包括macos kqueue, Solaris event port.

I/O 模型对比

telnet到底用的啥?

每种系统的实现不太一样

linux

/*
 * Check to see if any out-of-band data exists on a socket (for
 * Telnet "synch" processing).
 */

int
stilloob (void)
{
  static struct timeval timeout = { 0, 0 };
  fd_set excepts;
  int value;

  do
    {
      FD_ZERO (&excepts);
      FD_SET (net, &excepts);
      value =
  select (net + 1, (fd_set *) 0, (fd_set *) 0, &excepts, &timeout);
    }
  while ((value == -1) && (errno == EINTR));

  if (value < 0)
    {
      perror ("select");
      (void) quit ();
    }
  if (FD_ISSET (net, &excepts))
    {
      return 1;
    }
  else
    {
      return 0;
    }
}

freebsd

/*
 * Check to see if any out-of-band data exists on a socket (for
 * Telnet "synch" processing).
 */

int
stilloob(void)
{
    struct pollfd pfd[1];
    int value;

    do {
	pfd[0].fd = net;
	pfd[0].events = POLLRDBAND;
	value = poll(pfd, 1, 0);
    } while ((value == -1) && (errno == EINTR));

    if (value < 0) {
	perror("poll");
	quit();
    }
    if (pfd[0].revents & POLLRDBAND)
	return 1;
    else
	return 0;
}

go运行时中的network poller

go运行时中的network poller是对各种操作系统中的IO多路复用实现的统一封装. 根据不同的系统环境选择最优的实现.

runtime network poller 实现

network poller 向下对各种平台相关IO多路复用方法进行统一封装. 向上为标准库和运行时提供方法使用network poller.

统一定义的平台无关多路复用接口,各种实现都需要定义以下方法.

  // Integrated network poller (platform-independent part).
  // A particular implementation (epoll/kqueue/port/AIX/Windows)
  // must define the following functions:
  //
  // func netpollinit()
  //     Initialize the poller. Only called once.
  //
  // func netpollopen(fd uintptr, pd *pollDesc) int32
  //     Arm edge-triggered notifications for fd. The pd argument is to pass
  //     back to netpollready when fd is ready. Return an errno value.
  //
  // func netpollclose(fd uintptr) int32
  //     Disable notifications for fd. Return an errno value.
  //
  // func netpoll(delta int64) gList
  //     Poll the network. If delta < 0, block indefinitely. If delta == 0,
  //     poll without blocking. If delta > 0, block for up to delta nanoseconds.
  //     Return a list of goroutines built by calling netpollready.
  //
  // func netpollBreak()
  //     Wake up the network poller, assumed to be blocked in netpoll.
  //
  // func netpollIsPollDescriptor(fd uintptr) bool
  //     Reports whether fd is a file descriptor used by the poller.

提供给标准库使用相关的方法

func runtime_pollServerInit()
func runtime_pollOpen(fd uintptr) (uintptr, int)
func runtime_pollClose(ctx uintptr)
func runtime_pollWait(ctx uintptr, mode int) int
func runtime_pollWaitCanceled(ctx uintptr, mode int) int
func runtime_pollReset(ctx uintptr, mode int) int
func runtime_pollSetDeadline(ctx uintptr, d int64, mode int)
func runtime_pollUnblock(ctx uintptr)
func runtime_isPollServerDescriptor(fd uintptr) bool

提供给runtime使用的相关方法

func netpoll(delta int64) gList
func netpollBreak()

下面是相关主要方法在mac上使用kqueue的具体实现.

Network poller descriptor

  type pollDesc struct {
    link *pollDesc // in pollcache, protected by pollcache.lock

    // The lock protects pollOpen, pollSetDeadline, pollUnblock and deadlineimpl operations.
    // This fully covers seq, rt and wt variables. fd is constant throughout the PollDesc lifetime.
    // pollReset, pollWait, pollWaitCanceled and runtime·netpollready (IO readiness notification)
    // proceed w/o taking the lock. So closing, everr, rg, rd, wg and wd are manipulated
    // in a lock-free way by all operations.
    // NOTE(dvyukov): the following code uses uintptr to store *g (rg/wg),
    // that will blow up when GC starts moving objects.
    lock    mutex // protects the following fields
    fd      uintptr
    closing bool
    everr   bool      // marks event scanning error happened
    user    uint32    // user settable cookie
    rseq    uintptr   // protects from stale read timers
    rg      uintptr   // pdReady, pdWait, G waiting for read or nil
    rt      timer     // read deadline timer (set if rt.f != nil)
    rd      int64     // read deadline
    wseq    uintptr   // protects from stale write timers
    wg      uintptr   // pdReady, pdWait, G waiting for write or nil
    wt      timer     // write deadline timer
    wd      int64     // write deadline
    self    *pollDesc // storage for indirect interface. See (*pollDesc).makeArg.
  }

文件描述符在netpoller中的封装, 增加状态/定时器的相关附加字段.

Networker poller 初始化

//go:linkname poll_runtime_pollServerInit internal/poll.runtime_pollServerInit
  func poll_runtime_pollServerInit() {
    netpollGenericInit()
  }

func netpollGenericInit() {
				// ...
        netpollinit()
				// ...
  }

func netpollinit() {
  kq = kqueue()
  if kq < 0 {
    println("runtime: kqueue failed with", -kq)
    throw("runtime: netpollinit failed")
  }
  closeonexec(kq)
  r, w, errno := nonblockingPipe()
  if errno != 0 {
    println("runtime: pipe failed with", -errno)
    throw("runtime: pipe failed")
  }
  ev := keventt{
    filter: _EVFILT_READ,
    flags:  _EV_ADD,
  }
  *(*uintptr)(unsafe.Pointer(&ev.ident)) = uintptr(r)
  n := kevent(kq, &ev, 1, nil, 0, nil)
  if n < 0 {
    println("runtime: kevent failed with", -n)
    throw("runtime: kevent failed")
  }
  netpollBreakRd = uintptr(r)
  netpollBreakWr = uintptr(w)
}

初始化kqueue. (linux 是epoll)
使用pipe创建一对读写文件句柄, 并把获得的句柄加入kqueue中监听, 用于主动结束 netpoll等待

runtime_pollOpen 新增句柄

//go:linkname poll_runtime_pollOpen internal/poll.runtime_pollOpen
  func poll_runtime_pollOpen(fd uintptr) (*pollDesc, int) {
    pd := pollcache.alloc()
		
		// ... reset pd

    errno := netpollopen(fd, pd)
    if errno != 0 {
      pollcache.free(pd)
      return nil, int(errno)
    }
    return pd, 0
  }

func netpollopen(fd uintptr, pd *pollDesc) int32 {
  // Arm both EVFILT_READ and EVFILT_WRITE in edge-triggered mode (EV_CLEAR)
  // for the whole fd lifetime. The notifications are automatically unregistered
  // when fd is closed.
  var ev [2]keventt
  *(*uintptr)(unsafe.Pointer(&ev[0].ident)) = fd
  ev[0].filter = _EVFILT_READ
  ev[0].flags = _EV_ADD | _EV_CLEAR
  ev[0].fflags = 0
  ev[0].data = 0
  ev[0].udata = (*byte)(unsafe.Pointer(pd))
  ev[1] = ev[0]
  ev[1].filter = _EVFILT_WRITE
  n := kevent(kq, &ev[0], 2, nil, 0, nil)
  if n < 0 {
    return -n
  }
  return 0
}

将传入的句柄加入network poller的处理中.

netpoll 运行时检查获取ready的句柄

// netpoll checks for ready network connections.
// Returns list of goroutines that become runnable.
// delay < 0: blocks indefinitely
// delay == 0: does not block, just polls
// delay > 0: block for up to that many nanoseconds
func netpoll(delay int64) gList {
	// ....
  var events [64]keventt
retry:
  n := kevent(kq, nil, 0, &events[0], int32(len(events)), tp)
  if n < 0 {
		// ...
  }
  var toRun gList
  for i := 0; i < int(n); i++ {
    ev := &events[i]

		if uintptr(ev.ident) == netpollBreakRd {
		   // ...
    }

    var mode int32
    switch ev.filter {
    case _EVFILT_READ:
      mode += 'r'
      if ev.flags&_EV_EOF != 0 {
        mode += 'w'
      }
    case _EVFILT_WRITE:
      mode += 'w'
    }
    if mode != 0 {
      pd := (*pollDesc)(unsafe.Pointer(ev.udata))
      pd.everr = false
      if ev.flags == _EV_ERROR {
        pd.everr = true
      }
      netpollready(&toRun, pd, mode)
    }
  }
  return toRun
}

  func netpollready(toRun *gList, pd *pollDesc, mode int32) {
    var rg, wg *g
    if mode == 'r' || mode == 'r'+'w' {
      rg = netpollunblock(pd, 'r', true)
    }
    if mode == 'w' || mode == 'r'+'w' {
      wg = netpollunblock(pd, 'w', true)
    }
    if rg != nil {
      toRun.push(rg)
    }
    if wg != nil {
      toRun.push(wg)
    }
  }

func netpollunblock(pd *pollDesc, mode int32, ioready bool) *g {
    gpp := &pd.rg
    if mode == 'w' {
      gpp = &pd.wg
    }

    for {
      old := *gpp
      if old == pdReady {
        return nil
      }
      if old == 0 && !ioready {
        // Only set pdReady for ioready. runtime_pollWait
        // will check for timeout/cancel before waiting.
        return nil
      }
      var new uintptr
      if ioready {
        new = pdReady
      }
      if atomic.Casuintptr(gpp, old, new) {
        if old == pdWait {
          old = 0
        }
        return (*g)(unsafe.Pointer(old))
      }
    }
  }

runtime_pollWait goroutine等待某个句柄ready

// poll_runtime_pollWait, which is internal/poll.runtime_pollWait,
  // waits for a descriptor to be ready for reading or writing,
  // according to mode, which is 'r' or 'w'.
  // This returns an error code; the codes are defined above.
  //go:linkname poll_runtime_pollWait internal/poll.runtime_pollWait
  func poll_runtime_pollWait(pd *pollDesc, mode int) int {
    for !netpollblock(pd, int32(mode), false) {     
    }
    return pollNoError
  }

// returns true if IO is ready, or false if timedout or closed
  // waitio - wait only for completed IO, ignore errors
  func netpollblock(pd *pollDesc, mode int32, waitio bool) bool {
    gpp := &pd.rg
    if mode == 'w' {
      gpp = &pd.wg
    }

    // set the gpp semaphore to pdWait
    for {
      old := *gpp
      if old == pdReady {
        *gpp = 0
        return true
      }
      if old != 0 {
        throw("runtime: double wait")
      }
      if atomic.Casuintptr(gpp, 0, pdWait) {
        break
      }
    }

    // need to recheck error states after setting gpp to pdWait
    // this is necessary because runtime_pollUnblock/runtime_pollSetDeadline/deadlineimpl
    // do the opposite: store to closing/rd/wd, membarrier, load of rg/wg
    if waitio || netpollcheckerr(pd, mode) == 0 {
      gopark(netpollblockcommit, unsafe.Pointer(gpp), waitReasonIOWait, traceEvGoBlockNet, 5)
    }
    // be careful to not lose concurrent pdReady notification
    old := atomic.Xchguintptr(gpp, 0)
    if old > pdWait {
      throw("runtime: corrupted polldesc")
    }
    return old == pdReady
  }

检查句柄是否ready, 如果没有, gopark.

runtime_pollSetDeadline 设置等待超时时间

//go:linkname poll_runtime_pollSetDeadline internal/poll.runtime_pollSetDeadline
  func poll_runtime_pollSetDeadline(pd *pollDesc, d int64, mode int) {
	  // ...
    rd0, wd0 := pd.rd, pd.wd
    combo0 := rd0 > 0 && rd0 == wd0
    if d > 0 {
      d += nanotime()
      if d <= 0 {
        // If the user has a deadline in the future, but the delay calculation
        // overflows, then set the deadline to the maximum possible value.
        d = 1<<63 - 1
      }
    }
    if mode == 'r' || mode == 'r'+'w' {
      pd.rd = d
    }
    if mode == 'w' || mode == 'r'+'w' {
      pd.wd = d
    }
    combo := pd.rd > 0 && pd.rd == pd.wd
    rtf := netpollReadDeadline
    if combo {
      rtf = netpollDeadline
    }
    if pd.rt.f == nil {
      if pd.rd > 0 {
        pd.rt.f = rtf
        // Copy current seq into the timer arg.
        // Timer func will check the seq against current descriptor seq,
        // if they differ the descriptor was reused or timers were reset.
        pd.rt.arg = pd.makeArg()
        pd.rt.seq = pd.rseq
        resettimer(&pd.rt, pd.rd)
      }
    } else if pd.rd != rd0 || combo != combo0 {
      pd.rseq++ // invalidate current timers
      if pd.rd > 0 {
        modtimer(&pd.rt, pd.rd, 0, rtf, pd.makeArg(), pd.rseq)
      } else {
        deltimer(&pd.rt)
        pd.rt.f = nil
      }
    }
    if pd.wt.f == nil {
      if pd.wd > 0 && !combo {
        pd.wt.f = netpollWriteDeadline
        pd.wt.arg = pd.makeArg()
        pd.wt.seq = pd.wseq
        resettimer(&pd.wt, pd.wd)
      }
    } 
		// ...
	}

func netpolldeadlineimpl(pd *pollDesc, seq uintptr, read, write bool) {
		// ...
      rg = netpollunblock(pd, 'r', false)
    // ...
      wg = netpollunblock(pd, 'w', false)

    if rg != nil {
      netpollgoready(rg, 0)
    }
    if wg != nil {
      netpollgoready(wg, 0)
    }
  }

runtime_pollUnblock 取消等待, 让对应的goroutine ready

//go:linkname poll_runtime_pollUnblock internal/poll.runtime_pollUnblock
  func poll_runtime_pollUnblock(pd *pollDesc) {
    lock(&pd.lock)
    if pd.closing {
      throw("runtime: unblock on closing polldesc")
    }
    pd.closing = true
    pd.rseq++
    pd.wseq++
    var rg, wg *g
    atomic.StorepNoWB(noescape(unsafe.Pointer(&rg)), nil) // full memory barrier between store to closing and read of rg/wg in netpollunblock
    rg = netpollunblock(pd, 'r', false)
    wg = netpollunblock(pd, 'w', false)
    if pd.rt.f != nil {
      deltimer(&pd.rt)
      pd.rt.f = nil
    }
    if pd.wt.f != nil {
      deltimer(&pd.wt)
      pd.wt.f = nil
    }
    unlock(&pd.lock)
    if rg != nil {
      netpollgoready(rg, 3)
    }
    if wg != nil {
      netpollgoready(wg, 3)
    }
  }

自顶向下-从一个TCP server的视角看network poller

package main

import (
	"fmt"
	"net"
	"time"
)

func main() {
	l, err := net.Listen("tcp", ":8080")
	if err != nil {
		panic(err)
	}

	for {
		conn, err := l.Accept()
		if err != nil {
		}
		go serve(conn)
	}
}

func serve(conn net.Conn) {
	for {
		data := make([]byte, 1024)
		conn.SetDeadline(time.Now().Add(5 * time.Second))
		n, err := conn.Read(data)
		if err != nil {
			// check timeout
			if err, ok := err.(net.Error); ok && err.Timeout() {
				fmt.Println("timeout")
				continue
			}
			return
		}
		fmt.Printf("read %d byte data from %v\n", n, conn.RemoteAddr())
	}
}

程序监听:8080端口, net.Listen 会调用socket从os获得一个fd, 并把这个fd调用 poll_runtime_pollOpen internal/poll.runtime_pollOpen 注册进 network poller.
l.Accept(). main goroutine会

yaf框架的Bootstrap机制

2019-04-22T00:00:00+00:00

yaf框架的Bootstrap机制

Bootstrap是用来在Application运行(run)之前做一些初始化工作的机制.

1. Yaf_Bootstrap_Abstract

zend_class_entry *yaf_bootstrap_ce;

zend_function_entry yaf_bootstrap_methods[] = {
    {NULL, NULL, NULL}
};

YAF_STARTUP_FUNCTION(bootstrap) {
    zend_class_entry ce;

    YAF_INIT_CLASS_ENTRY(ce, "Yaf_Bootstrap_Abstract",  "Yaf\\Bootstrap_Abstract", yaf_bootstrap_methods);
    yaf_bootstrap_ce = zend_register_internal_class_ex(&ce, NULL);
    yaf_bootstrap_ce->ce_flags |= ZEND_ACC_EXPLICIT_ABSTRACT_CLASS;

    return SUCCESS;
}

Yaf_Bootstrap_Abstract在扩展代码中被定义为一个没有任何属性和方法的空抽象类。

2. Yaf_Application::bootstrap

Yaf_Application实例化之后,可以通过调用自身的boostrap方法，实现对用户自定义初始化代码的执行。下面看一下扩展内部bootstrap方法的逻辑.

导入(load)Boostrap类

    if (!(ce = zend_hash_str_find_ptr(EG(class_table),
                    YAF_DEFAULT_BOOTSTRAP_LOWER, sizeof(YAF_DEFAULT_BOOTSTRAP_LOWER) - 1))) {
        if (YAF_G(bootstrap)) {
            bootstrap_path = zend_string_copy(YAF_G(bootstrap));
        } else {
            bootstrap_path = strpprintf(0, "%s%c%s.%s",
                    ZSTR_VAL(YAF_G(directory)), DEFAULT_SLASH, YAF_DEFAULT_BOOTSTRAP, ZSTR_VAL(YAF_G(ext)));
        }
        if (!yaf_loader_import(bootstrap_path, 0)) {
            php_error_docref(NULL, E_WARNING, "Couldn't find bootstrap file %s", ZSTR_VAL(bootstrap_path));
            retval = 0;
        } else if (UNEXPECTED((ce = zend_hash_str_find_ptr(EG(class_table),
                        YAF_DEFAULT_BOOTSTRAP_LOWER, sizeof(YAF_DEFAULT_BOOTSTRAP_LOWER) - 1)) == NULL)) {
            php_error_docref(NULL, E_WARNING, "Couldn't find class %s in %s", YAF_DEFAULT_BOOTSTRAP, ZSTR_VAL(bootstrap_path));
            retval = 0;
        } else if (UNEXPECTED(!instanceof_function(ce, yaf_bootstrap_ce))) {
            php_error_docref(NULL, E_WARNING,
                    "Expect a %s instance, %s give", ZSTR_VAL(yaf_bootstrap_ce->name), ZSTR_VAL(ce->name));
            retval = 0;
        }
        zend_string_release(bootstrap_path);
    }

首先，在class_table中查找用户自定义的Bootstrap类(注册类名不分大小写). 如果查找失败执行引入流程，从bootstrap_path导入Bootstrap类，检查是否是Yaf_Bootstrap_Abstract抽象类.

执行所有_init开头方法

        object_init_ex(&bootstrap, ce);
        dispatcher = zend_read_property(yaf_application_ce,
                self, ZEND_STRL(YAF_APPLICATION_PROPERTY_NAME_DISPATCHER), 1, NULL);

        ZEND_HASH_FOREACH_STR_KEY(&(ce->function_table), func) {
            /* cann't use ZEND_STRL in strncasecmp, it cause a compile failed in VS2009 */
            if (strncasecmp(ZSTR_VAL(func), YAF_BOOTSTRAP_INITFUNC_PREFIX, sizeof(YAF_BOOTSTRAP_INITFUNC_PREFIX)-1)) {
                continue;
            }
            zend_call_method(&bootstrap, ce, NULL, ZSTR_VAL(func), ZSTR_LEN(func), NULL, 1, dispatcher, NULL);
            /** an uncaught exception threw in function call */
            if (UNEXPECTED(EG(exception))) {
                zval_ptr_dtor(&bootstrap);
                RETURN_FALSE;
            }
        } ZEND_HASH_FOREACH_END();
        zval_ptr_dtor(&bootstrap);

实例化Boostrap. 获取dispatcher实例，需要作为_init方法的参数.遍历执行ce(Bootstrap的实例)的所有以_init为前缀方法,完成用户自定义初始逻辑执行.

3. 动动手

删除Yaf_Application::bootstrap导入逻辑中的Boostrap实例检查,Boostrap类就不需要从Yaf_Bootstrap_Abstract继承啦. 只要你的自定义类名为Boostrap其中方法以_init开头.

nsq磁盘文件队列实现

2018-08-20T00:00:00+00:00

go-diskqueue

介绍

go-diskqueue是nsq内部使用的基于文件的磁盘队列库。nsqd内部topic/channel消息积压超过阀值后，后续进入的消息会被存储在各自的diskQueue中.

内部细节

元数据

// diskQueue implements a filesystem backed FIFO queue
type diskQueue struct {
    ...
    // run-time state (also persisted to disk)
    readPos      int64 // 队列读offset
    writePos     int64 // 队列写offset
    readFileNum  int64 // 读取文件序号
    writeFileNum int64 // 写入文件序号
    depth        int64 // 队列长度
    ...
}

diskQueue实例化时会先从元数据文件("%s.diskqueue.meta.dat")读出之前记录的运行时元数据, ioLoop goroutine从元数据记录的位置开始出入队操作.

示例元数据文件内容:

3323
0,0
0,348915

文件消息编码

消息格式:

    // parts:   dataLen       data
    // bits:  | - - - - | - - ... - - |
    // len:       4        dataLen

消息写入文件队列 (Put)

调用方调用Put([]byte)将消息传入writeChan, ioLoop从writeChan读取消息，写入文件队列.

写入过程(writeOne):

    // 如果writeFile为空，打开writeFile
    // Seek 至 d.wirtePos
    //           |
    //           V
    // 按编码格式编码消息流
    //           |
    //           V
    //  将消息流写入文件
    //           |
    //           V
    // 更新元信息
    // 如果writePos大于单个文件最大限制,
    // writeFileNum++, 重置writePos.关闭当前文件

读取文件队列消息 (ReadChan)

diskQueue通过ReadChan()将内部同步阻塞通道readChan暴露给外部使用，外部程序循环从readChan获取消费队列消息。

ioLoop中读取过程(readOne):

    // 如果readFile为空，打开readFile
    // Seek 至 d.readPos, 设置reader
    //           |
    //           V
    //   按编码格式读取消息流
    //           |
    //           V
    //       更新元信息
    //           |
    //           V
    // 如果nextReadPos大于单个文件最大限制,
    // nextReadFileNum++, 重置nextReadPos.关闭当前文件

ioLoop goroutine

diskQueue实例化完成后，ioLoop goroutine负责diskQueue内部主要处理逻辑:

    for {
        // dont sync all the time :)
        // 尝试fsync写入文件
        //           |
        //           |
        //           V
        // 尝试从文件队列读取一条消息 到dataRead,
        // 如果读取到消息 r=d.readChan, 否则r = nil,
        //           |
        //           |
        //           V
        select {
        // the Go channel spec dictates that nil channel operations (read or write)
        // in a select are skipped, we set r to d.readChan only when there is data to read
        case r <- dataRead:
            // 如果没有读到数据, r = nil, select语句会跳过
            // 如果有读到数据，尝试将数据送入readChan, 更新元数据
            count++
            // moveForward sets needSync flag if a file is removed
            d.moveForward()

        case dataWrite := <-d.writeChan:
            // 尝试读取写入文件, 写入文件队列
            count++
            d.writeResponseChan <- d.writeOne(dataWrite)

        case <-syncTicker.C:
            if count == 0 {
                // avoid sync when there's no activity
                continue
            }
            d.needSync = true

        case <-d.emptyChan:
            d.emptyResponseChan <- d.deleteAllFiles()
            count = 0
        case <-d.exitChan:
            goto exit
        }
    }

Damao

打造自己专属的开发环境

目标🎯

挑选shell

oh-my-zsh

插件

各种命令工具的插件

fish

挑选终端复用器

什么是终端复用器?

tmux

sessions

panes

windows

Zellij

挑选编辑器

emacs

vim

long live interface

手中无剑心中有剑🗡️

开始动手吧

准备工作🔨

dotfiles

一键部署脚本

vimtutor

梦开始的地方 ☁️

好东西

vim-slime

reference

B+树与数据库索引

曾经我有很多疑惑?

B+树

内存

磁盘

闪存(SSD)

B树 Familly

B+树

Innodb和B+树

聚簇索引(Clustered indexes)

二级索引(Secondary indexes)

联合索引(Multiple-Column Indexes)

其他

分表

碎片整理

参考

Go运行时network poller实现

network poller 是个啥?

实现telnet

blocking

nonblocking

I/O multiplexing

I/O 模型对比

telnet到底用的啥?

go运行时中的network poller

runtime network poller 实现

Network poller descriptor

Networker poller 初始化

runtime_pollOpen 新增句柄

netpoll 运行时检查获取ready的句柄

runtime_pollWait goroutine等待某个句柄ready

runtime_pollSetDeadline 设置等待超时时间

runtime_pollUnblock 取消等待, 让对应的goroutine ready

自顶向下-从一个TCP server的视角看network poller

yaf框架的Bootstrap机制

yaf框架的Bootstrap机制

1. Yaf_Bootstrap_Abstract

2. Yaf_Application::bootstrap

导入(load)Boostrap类

执行所有_init开头方法

3. 动动手

nsq磁盘文件队列实现

go-diskqueue

介绍

内部细节

元数据

文件消息编码

消息写入文件队列 (Put)

读取文件队列消息 (ReadChan)

ioLoop goroutine