cppcoffee.github.io

分析 rust 实现 TCP idle 连接池

2023-01-23T00:00:00+00:00

分析 rust 实现 TCP idle 连接池

简介

通常用 C 语言实现 TCP idle 连接池，是将 idle fd 放到 epoll_wait 中等待事件通知（对端主动断开链接等事件）。而更高级的语言如 go/rust 如果照搬 epoll_wait 实现，获取 inner fd 会失去语言封装的特性。

最近在阅读开源项目源码的时候，看到了 rust 实现的 ureq 库中的 TCP idle 连接池的实现，可以当作高级语言实现连接池的参考。

结构体

ureq 连接池的实现在 pool.rs 中，连接池结构体定义：

pub(crate) struct ConnectionPool {
    inner: Mutex<Inner>,
    max_idle_connections: usize,
    max_idle_connections_per_host: usize,
}

struct Inner {
    // the actual pooled connection. however only one per hostname:port.
    recycle: HashMap<PoolKey, VecDeque<Stream>>,
    // This is used to keep track of which streams to expire when the
    // pool reaches MAX_IDLE_CONNECTIONS. The corresponding PoolKeys for
    // recently used Streams are added to the back of the queue;
    // old streams are removed from the front.
    lru: VecDeque<PoolKey>,
}

空闲连接由 HashMap<PoolKey, VecDeque<String>> 存放，host:port 作为 key，连接存放到队列中。

空闲连接获取

ureq crate 从 connect_socket 接口获取 TCP 连接，如果 use_pooled 参数传递 true，就从连接池中获取连接。

/// Connect the socket, either by using the pool or grab a new one.
fn connect_socket(unit: &Unit, hostname: &str, use_pooled: bool) -> Result<(Stream, bool), Error> {
    ...

    if use_pooled {
        let pool = &unit.agent.state.pool;
        let proxy = &unit.agent.config.proxy;
        // The connection may have been closed by the server
        // due to idle timeout while it was sitting in the pool.
        // Loop until we find one that is still good or run out of connections.
        while let Some(stream) = pool.try_get_connection(&unit.url, proxy.clone()) {
            let server_closed = stream.server_closed()?;
            if !server_closed {
                return Ok((stream, true));
            }
            debug!("dropping stream from pool; closed by server: {:?}", stream);
        }
    }
    let stream = match unit.url.scheme() {
        "http" => stream::connect_http(unit, hostname),
        "https" => stream::connect_https(unit, hostname),
        "test" => connect_test(unit),
        scheme => Err(ErrorKind::UnknownScheme.msg(format!("unknown scheme {}", scheme))),
    };
    Ok((stream?, false))
}

函数循环从池子中获取连接，并调用 server_closed 判断空闲连接是否可用（没有被对端断开，没有残留数据）。

空闲连接需要判断是否断开的逻辑：

    // Check if the server has closed a stream by performing a one-byte
    // non-blocking read. If this returns EOF, the server has closed the
    // connection: return true. If this returns a successful read, there are
    // some bytes on the connection even though there was no inflight request.
    // For plain HTTP streams, that might mean an HTTP 408 was pushed; it
    // could also mean a buggy server that sent more bytes than a response's
    // Content-Length. For HTTPS streams, that might mean a close_notify alert,
    // which is the proper way to shut down an idle stream.
    // Either way, bytes available on the stream before we've made a request
    // means the stream is not usable, so we should discard it.
    // If this returns WouldBlock (aka EAGAIN),
    // that means the connection is still open: return false. Otherwise
    // return an error.
    fn serverclosed_stream(stream: &std::net::TcpStream) -> io::Result<bool> {
        let mut buf = [0; 1];
        stream.set_nonblocking(true)?;

        let result = match stream.peek(&mut buf) {
            Ok(n) => {
                debug!(
                    "peek on reused connection returned {}, not WouldBlock; discarding",
                    n
                );
                Ok(true)
            }
            Err(e) if e.kind() == io::ErrorKind::WouldBlock => Ok(false),
            Err(e) => Err(e),
        };
        stream.set_nonblocking(false)?;

        result
    }

将 stream 设置成非 blocking，调用 peak 判断是否对端已经断开连接或者有残留数据。

参考

https://github.com/algesten/ureq/blob/main/src/unit.rs

https://github.com/algesten/ureq/blob/main/src/stream.rs

ucontext实现mini协程库与优化

2022-02-02T00:00:00+00:00

ucontext实现mini协程库与优化

简介

Linux 下提供 ucontext 系列 API 来实现协程（coroutine）操作，协程可以由开发者实现调度。

ucontent 是 setjmp/longjmp 的高级版，支持携带参数调用。

ucontext APIs:

#include <ucontext.h>

int getcontext(ucontext_t *ucp);
int setcontext(const ucontext_t *ucp);

void makecontext(ucontext_t *ucp, void (*func)(), int argc, ...);
int swapcontext(ucontext_t *restrict oucp, const ucontext_t *restrict ucp);

使用 ucontext 系列 API 实现协程库需要实现基本的 coroutine yield/resume 接口，其中

resume: 重新执行协程暂停的位置
yield: 在当前点暂停协程的执行

实现

coroutine 状态

协程状态分成四种，定义四种协程状态

准备就绪(ready)
运行中(resume)
暂停中(yield)
运行完成(done)

typedef enum {
    COROUTINE_READY,
    COROUTINE_RUNNING,
    COROUTINE_SUSPEND,
    COROUTINE_DEAD,
} coroutine_status_e;

coroutine 结构体

协程结构体需要包含协程栈大小和协程相关状态，使用 stack_id 用于解决使用 valgrind 跟踪出现的栈变动警告。

typedef struct {
    ucontext_t              main;
    ucontext_t              ctx;

    // 协程执行入口函数与参数
    coroutine_pt            func;
    void                   *ud;

    // 协程栈指针与栈大小
    void                   *stack;
    size_t                  stack_size;

    // 协程运行状态
    coroutine_status_e       status;

    int                     stack_id;

    // 协程是否运行完成
    unsigned                done:1;
} coroutine_t;

coroutine_create

创建协程，指定协程运行函数的入口与参数，还有协程运行需要的栈大小。

如果指定栈大小为0，就使用 SIGSTKSZ 定义的大小。

coroutine_t *
coroutine_create(coroutine_pt fn, void *ud, size_t stack_size)
{
    coroutine_t  *co;
    size_t        size;

    if (stack_size == 0) {
        stack_size = SIGSTKSZ;
    }

    size = sizeof(*co) + stack_size;

    co = malloc(size);
    if (co == NULL) {
        return NULL;
    }

    memset(co, 0, sizeof(*co));

    // 设置协程执行入口函数和参数
    co->func = fn;
    co->ud = ud;

    // 栈与栈大小
    co->stack = co + 1;
    co->stack_size = stack_size;

    co->status = COROUTINE_READY;

    co->stack_id = VALGRIND_STACK_REGISTER(co, (void *) co + size);

    return co;
}

coroutine_resume

协程切换/调度，恢复协程运行，并更新协程状态。

int
coroutine_resume(coroutine_t *co)
{
    switch (co->status) {
    case COROUTINE_READY:
        if (getcontext(&co->ctx) == -1) {
            return CO_ERROR;
        }

        co->status = COROUTINE_RUNNING;

        co->ctx.uc_stack.ss_sp = co->stack;
        co->ctx.uc_stack.ss_size = co->stack_size;
        co->ctx.uc_stack.ss_flags = 0;
        co->ctx.uc_link = &co->main;

        // 协程主入口 coroutine_mainfunc
        makecontext(&co->ctx, (void (*)(void)) coroutine_mainfunc, 1, co);

        if (swapcontext(&co->main, &co->ctx) == -1) {
            return CO_ERROR;
        }

        break;

    case COROUTINE_SUSPEND:
        co->status = COROUTINE_RUNNING;

        if (swapcontext(&co->main, &co->ctx) == -1) {
            return CO_ERROR;
        }

        break;

    default:
        /* unreachable */
        assert(0);
    }

    if (co->done) {
        coroutine_destroy(co);
    }

    return CO_OK;
}

coroutine_mainfunc

协程运行的入口函数，间接的调用传递的入口函数，并设置协程完成标识位。

static void
coroutine_mainfunc(void *data)
{
    coroutine_t  *co = data;

    co->func(co->ud);

    co->done = 1;
}

coroutine_yield

协程暂停，切换到 main context 运行

int
coroutine_yield(coroutine_t *co)
{
    co->status = COROUTINE_SUSPEND;

    if (swapcontext(&co->ctx, &co->main) == -1) {
        return CO_ERROR;
    }

    return CO_OK;
}

协程优化

协程运行会频繁的调用 swapcontext 与 getcontext，如果继续使用 ucontext 系列结构，那么精简 ucontext 调用的汇编指令会是优化的关键

移除 swapcontext 内部调用设置的 sig_flags API 操作
移除参数寄存器 (x64 上面是 RDI, RDX, RCX, R8, R9 and RSI) 操作
移除浮点数寄存器操作

ucontext_i.h

定义寄存器存储的偏移量

#define SIG_BLOCK 0
#define SIG_SETMASK 2
#define _NSIG8 8
#define oRBP 120
#define oRSP 160
#define oRBX 128
#define oR8 40
#define oR9 48
#define oR10 56
#define oR11 64
#define oR12 72
#define oR13 80
#define oR14 88
#define oR15 96
#define oRDI 104
#define oRSI 112
#define oRDX 136
#define oRAX 144
#define oRCX 152
#define oRIP 168
#define oEFL 176
#define oFPREGS 224
#define oSIGMASK 296
#define oFPREGSMEM 424
#define oMXCSR 448

lightweight_getcontext

轻量级的 getcontext 实现

lightweight_getcontext.S
#include "ucontext_i.h"


.globl lightweight_getcontext;
.type lightweight_getcontext, @function;
lightweight_getcontext:
.cfi_startproc;
	/* Save the preserved registers, the registers used for passing
	   args, and the return address.  */
	movq	%rbx, oRBX(%rdi)
	movq	%rbp, oRBP(%rdi)
	movq	%r12, oR12(%rdi)
	movq	%r13, oR13(%rdi)
	movq	%r14, oR14(%rdi)
	movq	%r15, oR15(%rdi)

	movq	%rdi, oRDI(%rdi)
	movq	%rsi, oRSI(%rdi)
	movq	%rdx, oRDX(%rdi)
	movq	%rcx, oRCX(%rdi)
	movq	%r8, oR8(%rdi)
	movq	%r9, oR9(%rdi)

	movq	(%rsp), %rcx
	movq	%rcx, oRIP(%rdi)
	leaq	8(%rsp), %rcx		/* Exclude the return address.  */
	movq	%rcx, oRSP(%rdi)

	/* We have separate floating-point register content memory on the
	   stack.  We use the __fpregs_mem block in the context.  Set the
	   links up correctly.  */
	leaq	oFPREGSMEM(%rdi), %rcx
	movq	%rcx, oFPREGS(%rdi)
	/* Save the floating-point environment.  */
	fnstenv	(%rcx)
	stmxcsr oMXCSR(%rdi)

	/* Formerly here: a call to sigprocmask.
	   Deleted because unnecessary for our application. */

	/* All done, return 0 for success.  */
	xorl	%eax, %eax
	ret
.cfi_endproc;

lightweight_swapcontext

轻量级的 swapcontext 实现，移除了注册信号的系统调用

#include "ucontext_i.h"


.globl lightweight_swapcontext;
.type lightweight_swapcontext, @function;
lightweight_swapcontext:
.cfi_startproc;
	/* Save the preserved registers, the registers used for passing args,
	   and the return address.  */
	movq	%rbx, oRBX(%rdi)
	movq	%rbp, oRBP(%rdi)
	movq	%r12, oR12(%rdi)
	movq	%r13, oR13(%rdi)
	movq	%r14, oR14(%rdi)
	movq	%r15, oR15(%rdi)

	/* Don't bother saving  and restoring argument registers */
	movq	%rdi, oRDI(%rdi)
	movq	%rsi, oRSI(%rdi)
	movq	%rdx, oRDX(%rdi)
	movq	%rcx, oRCX(%rdi)
	movq	%r8, oR8(%rdi)
	movq	%r9, oR9(%rdi)

	movq	(%rsp), %rcx
	movq	%rcx, oRIP(%rdi)
	leaq	8(%rsp), %rcx		/* Exclude the return address.  */
	movq	%rcx, oRSP(%rdi)


	/* We have separate floating-point register content memory on the
	   stack.  We use the __fpregs_mem block in the context.  Set the
	   links up correctly.  */
	leaq	oFPREGSMEM(%rdi), %rcx
	movq	%rcx, oFPREGS(%rdi)
	/* Save the floating-point environment.  */
	fnstenv	(%rcx)
	stmxcsr oMXCSR(%rdi)

	/* Formerly here: a call to sigprocmask.
	   Deleted because unnecessary for our application. */

	/* Restore the floating-point context.  Not the registers, only the
	   rest.  */
	movq	oFPREGS(%rsi), %rcx
	fldenv	(%rcx)
	ldmxcsr oMXCSR(%rsi)

	/* Load the new stack pointer and the preserved registers.  */
	movq	oRSP(%rsi), %rsp
	movq	oRBX(%rsi), %rbx
	movq	oRBP(%rsi), %rbp
	movq	oR12(%rsi), %r12
	movq	oR13(%rsi), %r13
	movq	oR14(%rsi), %r14
	movq	oR15(%rsi), %r15

	/* The following ret should return to the address set with
	getcontext.  Therefore push the address on the stack.  */
	movq	oRIP(%rsi), %rcx
	pushq	%rcx

	/* Setup registers used for passing args--don't bother with this  */
	movq	oRDI(%rsi), %rdi
	movq	oRDX(%rsi), %rdx
	movq	oRCX(%rsi), %rcx
	movq	oR8(%rsi), %r8
	movq	oR9(%rsi), %r9

	/* Setup finally  %rsi.  */
	movq	oRSI(%rsi), %rsi

	/* Clear rax to indicate success.  */
	xorl	%eax, %eax
	ret
.cfi_endproc

References

https://github.com/cppcoffee/coroutine

https://man7.org/linux/man-pages/man3/swapcontext.3.html

https://github.com/cloudwu/coroutine

https://rethinkdb.com/blog/making-coroutines-fast/

IP防火墙 – XDP实现

2021-10-17T00:00:00+00:00

IP防火墙 – XDP实现

XDP 简介

XDP 在 linux 4.8 版本内核中引入，在位于数据包接受最早的数据点（还未分配 struct __sk_buff），可以直接对数据包改写、丢弃或转发等操作。

本文将用户层传递进来的规则进行操作（丢弃或允许），来实现 IP 防火墙的功能。

IP Block

实现分成两部分，用户接口部分与内核部分。

用户接口提供两个程序，分别是加载器和 IP规则修改：

ipblock-loader: XDP 加载器，将 IP Block XDP Prog 挂载到内核中：

# attach IP Block to eth2
./ipblock-loader -d eth2

# detach IP Block from eth2
./ipblock-loader -d eth2 -u

ipblock-rule: 通过 XDP 暴露的 MAP 结构，变更 IP Block 规则:

# droping IP packets for the ::ffff:c612:13/128
$ ./ipblock-rule -a ::ffff:c612:13/128 -p deny

# allow IP packets for the 192.168.31.0/24
$ ./ipblock-rule -a 192.168.31.0/24 -p allow

# delete rules
$ ./ipblock-rule -d ::ffff:c612:13/128
$ ./ipblock-rule -d 192.168.31.0/24

Map 存储结构

ipblock XDP 程序里定义 IPv4 和 IPv6 两个类型的前缀树 map，方便应用层调用 bpf helper API 进行操作。

map key 类型使用 bpf_lpm_triekey + sockaddr map value 类型为 enum xdp_action

IPv4 sockaddr 使用 uint32_t 类型存放（与 struct in_addr 类型的内存模型一致) IPv6 sockaddr 使用 struct in6_addr

如下所示：

struct lpm_v4_key {
    struct bpf_lpm_trie_key lpm;
    uint32_t                addr;
};

struct lpm_v6_key {
    struct bpf_lpm_trie_key lpm;
    struct in6_addr         addr;
};

// IPv4 map
struct {
    __uint(type, BPF_MAP_TYPE_LPM_TRIE);
    __uint(max_entries, MAX_RULES);
    __type(key, struct lpm_v4_key);
    __type(value, enum xdp_action);
    __uint(map_flags, BPF_F_NO_PREALLOC);
} ipv4_map SEC(".maps");

// IPv6 map
struct {
    __uint(type, BPF_MAP_TYPE_LPM_TRIE);
    __uint(max_entries, MAX_RULES);
    __type(key, struct lpm_v6_key);
    __type(value, enum xdp_action);
    __uint(map_flags, BPF_F_NO_PREALLOC);
} ipv6_map SEC(".maps");

XDP 实现逻辑

由于解析部分代码重复性比较多，做成了宏，简化重复的代码

#define PARSE_FUNC_DECLARATION(STRUCT)              \
static __always_inline                              \
struct STRUCT *parse_ ## STRUCT (struct cursor *c)  \
{                                                   \
    struct STRUCT *ret = c->pos;                    \
    if (c->pos + sizeof(struct STRUCT) > c->end) {  \
        return NULL;                                \
    }                                               \
    c->pos += sizeof(struct STRUCT);                \
    return ret;                                     \
}

PARSE_FUNC_DECLARATION(ethhdr)
PARSE_FUNC_DECLARATION(vlanhdr)
PARSE_FUNC_DECLARATION(iphdr)
PARSE_FUNC_DECLARATION(ipv6hdr)

struct cursor 使用保存了待解析的数据位置。

PARSE_FUNC_DECLARATION(iphdr) 宏定义展开后，生成如下代码：

static __always_inline
struct iphdr *parse_iphdr(struct cursor *c)
{
    struct iphdr *ret = c->pos;
    if (c->pos + sizeof(struct iphdr) > c->end) {
        return NULL;
    }
    c->pos += sizeof(struct iphdr);
    return ret;
}

以下是数据包处理逻辑：

SEC("xdp")
int xdp_prog(struct xdp_md *ctx)
{
    ...

    rc = XDP_PASS;

    cursor_init(&c, ctx);

    // 解析 eth header
    eth = parse_eth(&c, &eth_proto);
    if (eth == NULL) {
        goto pass;
    }

    // 解析 IP header
    if (eth_proto == bpf_htons(ETH_P_IP)) {
        iph = parse_iphdr(&c);
        if (iph == NULL) {
            goto pass;
        }

        // 从 ipv4 map 中拿到 action
        rc = ip_map_lookup_value(&ipv4_map, iph->saddr);

    } else if (eth_proto == bpf_htons(ETH_P_IPV6)) {
        ip6h = parse_ipv6hdr(&c);
        if (ip6h == NULL) {
            goto pass;
        }

        // 从 ipv6 map 中拿到 action
        rc = ip6_map_lookup_value(&ipv6_map, ip6h->saddr);
    }

pass:

    return rc;
}

ipblock-loader

ipblock-loader 是 XDP 加载器，用于将 XDP program 挂载到指定网卡中。

static int
do_load(struct options *opt, struct ipblock_bpf *skel)
{
    int             err;

    // 挂载 XDP 到指定网卡
    err = xdp_link_attach(opt->ifindex, opt->xdp_flags,
                          bpf_program__fd(skel->progs.xdp_prog));
    if (err != 0) {
        return err;
    }

    // PIN map 到 bpf fs 中
    err = pin_maps_in_bpf_object(skel);
    if (err != 0) {
        return err;
    }

    return 0;
}

挂载成功后，将 map PIN 到 bpf fs，路径分别为：

/sys/fs/bpf/ipblock/ipv4_map
/sys/fs/bpf/ipblock/ipv6_map

ipblock-rule

ipblock-rule 实现为规则控制程序，用于增删改规则

static int
do_add_cmd(options_t *opt)
{
    ...

    // 根据 IP地址类型，打开对应的 bpf map
    fd = open_bpf_map(opt->cidr.af);

    ...

    // 设置 bpf_lpm_trie_key
    lpm = malloc(sizeof(*lpm) + opt->cidr.socklen);
    lpm->prefixlen = opt->cidr.prefixlen;
    memcpy(lpm->data, &opt->cidr.sockaddr, opt->cidr.socklen);

    // BPF_ANY 增加或更新规则
    if (bpf_map_update_elem(fd, lpm, &opt->action, BPF_ANY) != 0) {
        ...
    }

    ...
}

详细代码在文末的 github 仓库链接中。

Reference

BPF and XDP Reference Guide

github libbpf

BPF Portability and CO-RE

https://github.com/cppcoffee/ipblock

Hugepage 内存分配器 – Rust实现

2021-07-24T00:00:00+00:00

Hugepage 内存分配器 – Rust实现

HugePage简介

Linux 默认内存页大小是 4KB（x86和x86_64），hugepage 的特性允许内核管理比默认内存页还要大的内存页（Huge Page）。

在 Linux 虚拟内存系统中维护一张 TLB（Translation Lookaside Buffer）的表，该表用于虚拟内存地址映射到物理内存地址。当系统需要访问一个虚拟内存位置时，需要进行 TLB 查找并进行地址转换。

启用 HugePages 后，系统使用更少的页表，减少了维护和访问页表的开销。Hugepages 保持在内存中，不被 swap，所以内核 swap 守护程序没有管理它们的工作，内核也不需要为它们执行页表查找。较少的页面数量减少了执行内存操作的开销，同时也减少了访问页表时出现瓶颈的可能性。

HugePage 在 x86 上是 4MB，x86_64 是 2MB。

关于 Hugepages 更详细的内容可以参考本文末尾的 References。

HugePage API

Linux 提供 mmap(MAP_HUGETLB) 来分配 hugepages，如下调用分配 len 长度的 hugepages。flags 参数传递 MAP_HUGETLB：

int flags = MAP_PRIVATE | MAP_ANONYMOUS | MAP_HUGETLB;

void *p = mmap(null_ptr, len, PROT_READ | PROT_WRITE, flags, -1, 0);

Allocator

接下来使用 rust 实现一个 hugepage 分配器

const MEMINFO_PATH: &str = "/proc/meminfo";
const TOKEN: &str = "Hugepagesize:";

lazy_static! {
    // 从 '/proc/meminfo' 中解析出 'Hugepagesize' 来初始化全局变量 HUGEPAGE_SIZE
    // HUGEPAGE_SIZE 用于 Allocator 分配内存时做对齐用。
    static ref HUGEPAGE_SIZE: isize = {
        let buf = File::open(MEMINFO_PATH).map_or("".to_owned(), |mut f| {
            let mut s = String::new();
            let _ = f.read_to_string(&mut s);
            s
        });
        parse_hugepage_size(&buf)
    };
}

// 解析 Hugepagesize
// meminfo 内容存在多行，需一行行找到 TOKEN='Hugepagesize:' 并对值进行解析
fn parse_hugepage_size(s: &str) -> isize {
    for line in s.lines() {
        // 找到 ‘Hugepagesize:’ 前缀
        if line.starts_with(TOKEN) {
            let mut parts = line[TOKEN.len()..].split_whitespace();

            // parse size
            let p = parts.next().unwrap_or("0");
            let mut hugepage_size = p.parse::<isize>().unwrap_or(-1);

            // parse unit
            hugepage_size *= parts.next().map_or(1, |x| match x {
                // 当前支持 kB 解析
                "kB" => 1024,
                _ => 1,
            });

            return hugepage_size;
        }
    }

    return -1;
}

定义 Allocator 结构体，采用空结构体类型（不需要内部数据，所以无任何结构字段）

pub(crate) struct HugePageAllocator;

使用 libc crate 提供的接口来调用 libc::mmap。那么接下来实现 std::alloc::GlobalAlloc trait：

// 实现 GlobalAlloc trait
unsafe impl GlobalAlloc for HugePageAllocator {
    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
        // 分配的内存大小需对齐 HUGEPAGE_SIZE，调用辅助函数 align_to
        let len = align_to(layout.size(), *HUGEPAGE_SIZE as usize);
        let p = libc::mmap(
            null_mut(),
            len,
            PROT_READ | PROT_WRITE,
            MAP_PRIVATE | MAP_ANONYMOUS | MAP_HUGETLB,
            -1,
            0,
        );

        // 无法分配 hugepage 则返回 null.
        if p == MAP_FAILED {
            return null_mut();
        }

        p as *mut u8
    }

    // 删除时候也需要 layout 参数.
    unsafe fn dealloc(&self, p: *mut u8, layout: Layout) {
        libc::munmap(p as *mut c_void, layout.size());
    }
}

// 辅助函数，用于对其字节
fn align_to(size: usize, align: usize) -> usize {
    (size + align - 1) & !(align - 1)
}

以上就完成了简单的 Hugepage 分配器。

Boxed

实现 Allocator 后，导出一个全局的 Allocator 给 Box 使用。

// lib.rs 定义一个全局的 default_allocator() 接口，给整个 crate 使用。
lazy_static! {
    static ref HUGEPAGE_ALLOCATOR: HugePageAllocator = HugePageAllocator;
}

// 只暴露给自身 crate 调用
pub(crate) fn default_allocator() -> &'static HugePageAllocator {
    &HUGEPAGE_ALLOCATOR
}

实现一个简单的 Box，支持 deref 操作，过了 Box scope 后，自动释放，具体实现如下：

pub struct Box<T> {
    data: NonNull<T>,
}

impl<T> Box<T> {
    pub fn new(data: T) -> Box<T> {
        let layout = Layout::new::<T>();
        unsafe {
            let mut p = NonNull::new(default_allocator().alloc(layout) as *mut T).unwrap();
            *(p.as_mut()) = data;
            Self { data: p }
        }
    }

    pub unsafe fn from_raw(raw: *mut T) -> Self {
        Self {
            data: NonNull::new(raw).unwrap(),
        }
    }
}

impl<T> Drop for Box<T> {
    fn drop(&mut self) {
        unsafe {
            default_allocator().dealloc(self.data.as_ptr() as *mut u8, Layout::new::<T>());
        }
    }
}

impl<T> Deref for Box<T> {
    type Target = T;
    fn deref(&self) -> &T {
        unsafe { self.data.as_ref() }
    }
}

impl<T> DerefMut for Box<T> {
    fn deref_mut(&mut self) -> &mut T {
        unsafe { self.data.as_mut() }
    }
}

更详细的代码在文末给的 github 仓库中。

Reference

Huge pages part 1 (Introduction)

Huge pages part 2: Interfaces

Huge pages part 3: Administration

Huge pages part 4: benchmarking with huge pages

Huge pages part 5: A deeper look at TLBs and costs

https://www.kernel.org/doc/Documentation/vm/hugetlbpage.txt

https://man7.org/linux/man-pages/man2/mmap.2.html

https://github.com/cppcoffee/hugepage-rs

自旋读写锁实现

2021-05-13T00:00:00+00:00

自旋读写锁实现

读写锁

读写锁是并发控制的一种同步机制，也称 “共享-互斥锁”、多读者-单写者锁。读操作可以并发重入，写操作是互斥的。

读写锁实现有多种方式，本文描述的是 自旋读写锁 的实现。

优先策略

读写锁的策略分为：

读操作优先：允许最大并发，但写操作可能饿死。
写操作优先：一旦所有已经开始的读操作完成，等待的写操作立即获得锁。
未指定优先级

本文实现的读写锁策略是 写操作优先

自旋读写锁的设计

采用 uint64_t（64位整形）类型作为锁内部值。

写操作占用 1 位最高位，其余位用于读操作。

写操作位用十六进制表示为 0x8000000000000000，每次只能有一个写锁操作。退出时重置写操作位。

读操作位支持多个并发读操作，最高支持 0x7FFFFFFFFFFFFFFF 个读操作。每发生一次读锁定操作，则增加 1，退出时减少 1。

备注：读写都使用 CAS 操作。

实现

自旋读写锁 C 语言实现

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <assert.h>


static const uint64_t SHARED_LOCK_INIT = 0;
static const uint64_t SHARED_LOCK_WRITER_BIT = 1UL << 63;


typedef struct shared_rwlock_s    shared_rwlock_t;

struct shared_rwlock_s {
    uint64_t  lock;
};


void shared_lock_init(shared_rwlock_t *p)
{
    p->lock = SHARED_LOCK_INIT;
}


void shared_read_lock(shared_rwlock_t *p)
{
    uint64_t value;

    for ( ;; ) {
        value = p->lock;

        // is wirte locked?
        if (value >= SHARED_LOCK_WRITER_BIT) {
            continue;
        }

        // increase reader bit.
        if (__sync_bool_compare_and_swap(&p->lock, value, value + 1)) {
            break;
        }
    }
}


void shared_read_unlock(shared_rwlock_t *p)
{
    assert(p->lock > SHARED_LOCK_INIT);

    __sync_sub_and_fetch(&p->lock, 1);
}


void shared_write_lock(shared_rwlock_t *p)
{
    uint64_t value;

    for ( ;; ) {
        value = p->lock;

        // is wirte locked?
        if (value >= SHARED_LOCK_WRITER_BIT) {
            continue;
        }

        // set write lock bit.
        if (__sync_bool_compare_and_swap(&p->lock, value, value | SHARED_LOCK_WRITER_BIT)) {
            break;
        }
    }

    // wait for active readers.
    while (p->lock != SHARED_LOCK_WRITER_BIT) { /* void */ }
}


void shared_write_unlock(shared_rwlock_t *p)
{
    assert(p->lock == SHARED_LOCK_WRITER_BIT);

    __sync_sub_and_fetch(&p->lock, SHARED_LOCK_WRITER_BIT);
}

附加功能

在锁内部增加一个循环等待上限值，当循环计数到达阈值时，仍然没有获得锁，让出当前 CPU 时间片。

伪代码

count = 0;

for ( ;; ) {
    if (is_write_locked(&rwlock)) {
        if (++count >= limit_rate) {
            count = 0;
            sched_yield();
        }
    }
    ...
}

Rust 实现版本

该版本读写锁使用 RAII 哨兵，并增加了 owner 字段，能够发现自身线程在使用过程中产生的死锁问题。

use std::cell::UnsafeCell;
use std::ops::{Deref, DerefMut};
use std::sync::atomic::{AtomicU64, Ordering};

use crate::{Error, Result};

// The writer lock bit.
const SHARED_LOCK_WRITER_BIT: u64 = 1u64 << 63;

unsafe impl<T> Send for SharedLock<T> {}
unsafe impl<T> Sync for SharedLock<T> {}

/*
 * A reader-writer lock
 */
pub struct SharedLock<T: ?Sized> {
    inner: AtomicU64,
    owner: AtomicU64,
    data: UnsafeCell<T>,
}

impl<T> SharedLock<T> {
    pub fn new(t: T) -> Self {
        SharedLock {
            inner: AtomicU64::default(),
            owner: AtomicU64::default(),
            data: UnsafeCell::new(t),
        }
    }
}

impl<T: ?Sized> SharedLock<T> {
    pub fn read(&self) -> Result<SharedLockReadGuard<'_, T>> {
        SharedLockReadGuard::new(self)
    }

    pub fn write(&self) -> Result<SharedLockWriteGuard<'_, T>> {
        SharedLockWriteGuard::new(self)
    }

    fn is_hold(&self) -> bool {
        let tid = self.owner.load(Ordering::Acquire);
        tid > 0 && tid == unsafe { libc::pthread_self() } as u64
    }

    fn set_owner_id(&self, tid: u64) {
        self.owner.store(tid, Ordering::Release);
    }
}

/*
 * RAII structure used to release the shared read access of a lock when dropped.
 * This structure is created by the read methods on SharedLock.
 */
pub struct SharedLockReadGuard<'a, T: ?Sized + 'a> {
    lock: &'a SharedLock<T>,
}

impl<'a, T: ?Sized> SharedLockReadGuard<'a, T> {
    fn new(lock: &'a SharedLock<T>) -> Result<SharedLockReadGuard<'a, T>> {
        if lock.is_hold() {
            return Err(Error::DeadLockError);
        }

        loop {
            let value = lock.inner.load(Ordering::Acquire);
            if value >= SHARED_LOCK_WRITER_BIT {
                continue;
            }

            if lock
                .inner
                .compare_exchange(value, value + 1, Ordering::Release, Ordering::Relaxed)
                .is_ok()
            {
                break;
            }
        }

        Ok(SharedLockReadGuard { lock })
    }
}

impl<T: ?Sized> Deref for SharedLockReadGuard<'_, T> {
    type Target = T;

    fn deref(&self) -> &T {
        unsafe { &*self.lock.data.get() }
    }
}

impl<T: ?Sized> Drop for SharedLockReadGuard<'_, T> {
    fn drop(&mut self) {
        self.lock.inner.fetch_sub(1, Ordering::Release);
    }
}

/*
 * RAII structure used to release the exclusive write access of a lock when dropped.
 * This structure is created by the write methods on SharedLock.
 */
pub struct SharedLockWriteGuard<'a, T: ?Sized + 'a> {
    lock: &'a SharedLock<T>,
}

impl<'a, T: ?Sized> SharedLockWriteGuard<'a, T> {
    fn new(lock: &'a SharedLock<T>) -> Result<SharedLockWriteGuard<'a, T>> {
        if lock.is_hold() {
            return Err(Error::DeadLockError);
        }

        loop {
            let value = lock.inner.load(Ordering::Acquire);
            if value >= SHARED_LOCK_WRITER_BIT {
                continue;
            }

            if lock
                .inner
                .compare_exchange(
                    value,
                    value | SHARED_LOCK_WRITER_BIT,
                    Ordering::Release,
                    Ordering::Relaxed,
                )
                .is_ok()
            {
                break;
            }
        }

        if lock.owner.load(Ordering::Acquire) != 0 {
            return Err(Error::Poisoned);
        }
        lock.set_owner_id(unsafe { libc::pthread_self() } as u64);

        // wait for active readers.
        while lock.inner.load(Ordering::Acquire) != SHARED_LOCK_WRITER_BIT {}

        Ok(SharedLockWriteGuard { lock })
    }
}

impl<T: ?Sized> Deref for SharedLockWriteGuard<'_, T> {
    type Target = T;

    fn deref(&self) -> &T {
        unsafe { &*self.lock.data.get() }
    }
}

impl<T: ?Sized> Drop for SharedLockWriteGuard<'_, T> {
    fn drop(&mut self) {
        let value = self.lock.inner.load(Ordering::Acquire);

        if value != SHARED_LOCK_WRITER_BIT {
            panic!("write unlock inner value: {}", value);
        }

        // reset owner id.
        if !self.lock.is_hold() {
            panic!(
                "Poisoned!!! owner id: {}",
                self.lock.owner.load(Ordering::Acquire)
            );
        }
        self.lock.set_owner_id(0);

        self.lock
            .inner
            .fetch_sub(SHARED_LOCK_WRITER_BIT, Ordering::Release);
    }
}

impl<T: ?Sized> DerefMut for SharedLockWriteGuard<'_, T> {
    fn deref_mut(&mut self) -> &mut T {
        unsafe { &mut *self.lock.data.get() }
    }
}

参考

https://github.com/cppcoffee/sharelock-rs

https://en.wikipedia.org/wiki/Readers%E2%80%93writer_lock

Process crash print stacktrace – C Library

2021-04-25T00:00:00+00:00

Process crash print stacktrace – C Library

简述

在使用非内存安全，直接操作内存指针的计算机语言进行开发时，不免会碰到操作野指针、回收再访问的内存等等让进程崩溃的情况。

进程 crash 后，如果有开启 coredump 功能，linux 系统会 dump 进程相关信息到文件中。在不安装 debug-info 源码包查看 coredump 产生的 core 崩溃的堆栈信息，可以使用如下 gdb 命令：

# batch mode 下，执行 bt 打印堆栈
gdb -batch -c ./coredump-nginx-pid -ex bt /bin/nginx

coredump 开启后，碰到 crash 的进程占用较大内存时，导致 dump 进程数据到磁盘过程过长，机械磁盘负载会持续飙高。

但如果限制了 coredump 次数与 coredump 文件的大小，会导致某些条件的 coredump 无法被发现。

本文描述开发 crash 输出栈信息到 C Library 的实现。

crash 调用栈信息输出

如果进程 crash 后，将导致 crash 的调用栈信息输出到文件，这样可以方便查找问题。

主要逻辑如下：

进程启动后，调用库的初始化，注册进程 crash 的信号处理
当 crash 发生后，调用信号处理函数
在处理函数中，将调用栈输出到 stderr
重新设置默认信号 handler，向上传递发生的信号

该 C Library 依赖 libbfd (Binary File Descriptor library)，使用它来解析 elf sections，找出调用栈函数名和代码行。

libbfd 由 binutils package 提供，在 CentOS 中，可以使用下列命令行进行安装：

yum install binutils-devel -y

主要实现

下列代码将 crash 的信息输出到 stderr。

更详细的代码见文末 github libstacktrace 仓库链接

部分主要逻辑如下：

#define _GNU_SOURCE
#include <execinfo.h>
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <signal.h>
#include <unistd.h>

#include "symbol_table.h"


// The max number of levels in the stack trace
#define STACK_TRACE_MAX_LEVELS  100
#define BUFFER_LENGTH           4096


typedef void (*signal_handler_t)(int signo, siginfo_t *info, void *ctx);

static void register_crash_handlers();
static int backtrace_symbol_write(int fd, const char *text, void *addr);


// store process full path.
static char program_path[PATH_MAX];
// the current program binary symbol table.
static symbol_table_t symtab;


// initialize stacktrace library.
int init_stacktrace()
{
    int n;

    n = readlink("/proc/self/exe", program_path, PATH_MAX);
    if (n < 0 || n >= PATH_MAX) {
        return -1;
    }

    program_path[n] = '\0';

    if (symbol_table_build(program_path, &symtab) != 0) {
        return -2;
    }

    register_crash_handlers();

    return 0;
}


static void
stack_trace_dump()
{
    int             i, btl;
    char          **strings;
    void           *stack[STACK_TRACE_MAX_LEVELS + 1];
    const char     *msg = " - STACK TRACE: \n";

    if (write(STDERR_FILENO, program_path, strlen(program_path)) == -1) {
        return;
    }

    if (write(STDERR_FILENO, msg, strlen(msg)) == -1) {
        return;
    }

    memset(stack, 0, sizeof(stack));

    if ((btl = backtrace(stack, STACK_TRACE_MAX_LEVELS)) > 2) {
        strings = backtrace_symbols(stack, btl);
        if (strings != NULL) {
            for (i = 2; i < btl; i++) {
                backtrace_symbol_write(STDERR_FILENO, strings[i], stack[i]);
            }

            free(strings);

        } else {
            backtrace_symbols_fd(stack + 2, btl - 2, STDERR_FILENO);
        }
    }
}


// Reset a signal handler to the default handler.
static void
signal_reset_default(int signo)
{
    struct sigaction act;

    act.sa_handler = SIG_DFL;
    act.sa_flags   = SA_NODEFER | SA_ONSTACK | SA_RESETHAND;
    sigemptyset(&(act.sa_mask));

    assert(sigaction(signo, &act, NULL) == 0);
}


static void
signal_crash_handler(int signo, siginfo_t *siginfo, void *data)
{
    stack_trace_dump();

    signal_reset_default(signo);
    // throw signal to default handler.
    raise(signo);
}


static void
set_signal(int signo, signal_handler_t handler)
{
    struct sigaction act;

    act.sa_handler   = NULL;
    act.sa_sigaction = handler;
    act.sa_flags     = SA_SIGINFO;
    sigemptyset(&(act.sa_mask));

    assert(sigaction(signo, &act, NULL) == 0);
}


static void
register_crash_handlers()
{
    set_signal(SIGBUS,  signal_crash_handler);
    set_signal(SIGSEGV, signal_crash_handler);
    set_signal(SIGILL,  signal_crash_handler);
    set_signal(SIGTRAP, signal_crash_handler);
    set_signal(SIGFPE,  signal_crash_handler);
    set_signal(SIGABRT, signal_crash_handler);
}


static int
backtrace_symbol_format(char *buf, size_t len, const char *prefix, frame_record_t fr)
{
    int     n;
    char   *p = buf;

    // file name
    if (fr.filename != NULL) {
        n = snprintf(p, len, "%s %s", prefix, fr.filename);

    } else {
        n = snprintf(p, len, "%s ??", prefix);
    }

    p += n;
    len -= n;

    // function name
    if (fr.functionname != NULL && *fr.functionname != '\0') {
        n = snprintf(p, len, " %s()", fr.functionname);

    } else {
        n = snprintf(p, len, " ??");
    }

    p += n;
    len -= n;

    // line
    if (fr.line != 0) {
        n = snprintf(p, len, ":%u", fr.line);

        p += n;
        len -= n;
    }

    // discriminator
    if (fr.discriminator != 0) {
        n = snprintf(p, len, " (discriminator %u)\n", fr.discriminator);

    } else {
        n = snprintf(p, len, "\n");
    }

    p += n;
    len -= n;

    return p - buf;
}


static int
backtrace_symbol_write(int fd, const char *text, void *addr)
{
    frame_record_t  fr;
    int             n;
    char            buf[BUFFER_LENGTH + 1];

    if (symbol_table_find(&symtab, addr, &fr)) {
        n = backtrace_symbol_format(buf, BUFFER_LENGTH, text, fr);

    } else {
        n = snprintf(buf, BUFFER_LENGTH, "%s\n", text);
    }

    buf[n] = '\0';

    if (write(fd, buf, strlen(buf)) == -1) {
        return -1;
    }

    return 0;
}

崩溃栈输出

在 example.c 中，有个访问空指针的代码，导致 crash，完整代码如下：

#include <stdio.h>
#include "stacktrace.h"


static void bar()
{
    // 访问空指针，导致 crash
    char *p = 0;
    *p = 'a';
}


static void foo()
{
    bar();
}


int main()
{
    // 初始化 library
    init_stacktrace();

    foo();

    return 0;
}

运行后，example 进程 crash 输出：

[root@localhost libstacktrace]# ./example
/home/sharp/libstacktrace/example - STACK TRACE:
/lib64/libc.so.6(+0x36450) [0x7fca8db52450]
./example() [0x4036f0] example.c bar()
./example() [0x403703] example.c foo()
./example() [0x40371d] ?? main()
/lib64/libc.so.6(__libc_start_main+0xf5) [0x7fca8db3e555]
./example() [0x402c9a] ?? _start()
Segmentation fault

如果使用 -g 编译，crash 输出更详细，包括崩溃的具体代码行：

[root@localhost libstacktrace]# ./example
/home/sharp/libstacktrace/example - STACK TRACE:
/lib64/libc.so.6(+0x36450) [0x7fa21a2e0450]
./example() [0x4036f0] /home/sharp/libstacktrace/example.c bar():8
./example() [0x403703] /home/sharp/libstacktrace/example.c foo():15
./example() [0x40371d] /home/sharp/libstacktrace/example.c main():24
/lib64/libc.so.6(__libc_start_main+0xf5) [0x7fa21a2cc555]
./example() [0x402c9a] ?? _start()
Segmentation fault

参考

https://github.com/cppcoffee/libstacktrace

https://man7.org/linux/man-pages/man1/gdb.1.html

https://man7.org/linux/man-pages/man1/addr2line.1.html

https://github.com/apache/trafficserver/blob/master/src/tscore/signals.cc

https://sourceware.org/binutils/docs/bfd/

Lock-Free Stack Implement

2021-04-07T00:00:00+00:00

Lock-Free Stack Implement

无锁链式栈

栈是一种 LIFO （Last In First Out）的数据结构，常见的实现有数组的方式，操作数组索引进行出入栈；还有另外一种是链式栈实现，操作指针进行出入栈。本文将讨论的是基于链式栈实现无锁操作。

链式栈是一种单向链表的结构体，每个节点有一个 next 指针，指向当前栈的下一个栈节点。

最基本操作：栈的初始化、入栈、出栈。

实现

这里采用 Rust 实现，crossbeam-epoch crate 来解决无锁结构体的 ABA 问题和内存回收问题。

结构体

栈的结构体需要有一个指针指向当前栈的栈顶，由于只需要原子操作一个栈顶指针，实现起来将会变得简单。

栈结构体和栈节点的结构体定义如下：

// 链式栈节点结构体
struct Node<T: Send> {
    next: Atomic<Node<T>>,  // 下一个节点
    value: Option<T>,       // 存储的值
}

// 栈对象结构体
pub struct Stack<T: Send> {
    top: Atomic<Node<T>>,
}

初始化

初始化不需要原子操作，这里提供两个方法：

impl<T: Send> Node<T> {
    // 普通节点
    fn new(v: T) -> Self {
        Self {
            next: Atomic::null(),
            value: Some(v),
        }
    }

    // 哨兵节点
    fn sentinel() -> Self {
        Self {
            next: Atomic::null(),
            value: None,
        }
    }
}

push/压栈

压栈操作是将栈顶指针设置为新压入的栈节点。

pub fn push(&self, v: T) {
    unsafe { self.try_push(v) }
}

unsafe fn try_push(&self, v: T) {
    let guard = &epoch::pin();
    let node = Owned::new(Node::new(v)).into_shared(guard);

    loop {
        let top_ptr = self.top.load(Acquire, guard);
        // 新节点的下一个节点指向栈顶
        (*node.as_raw()).next.store(top_ptr, Relaxed);

        // 设置 top 为新节点
        if self
            .top
            .compare_exchange(top_ptr, node, Release, Relaxed, guard)
            .is_ok()
        {
            break;
        }
    }
}

pop/出栈

出栈操作是将栈顶指针设置为栈顶的下一个栈节点

pub fn pop(&self) -> Option<T> {
    unsafe { self.try_pop() }
}

unsafe fn try_pop(&self) -> Option<T> {
    let guard = &epoch::pin();

    loop {
        let top_ptr = self.top.load(Acquire, guard);
        let next_ptr = (*top_ptr.as_raw()).next.load(Acquire, guard);

        if next_ptr.is_null() {
            return None;
        }

        // 设置栈顶指针为栈顶的下一个栈节点
        if self
            .top
            .compare_exchange(top_ptr, next_ptr, Release, Relaxed, guard)
            .is_ok()
        {
            let top_ptr = top_ptr.as_raw() as *mut Node<T>;
            return (*top_ptr).value.take();
        }
    }
}

完整代码链接放在文末参考字段

性能测试

lib.rs Stack 与标准库的 Mutex 类型进行压测对比

笔记本电脑 CPU 参数如下:

machdep.cpu.brand_string: Intel(R) Core(TM) i5-4278U CPU @ 2.60GHz
machdep.cpu.core_count: 2
machdep.cpu.thread_count: 4

压测描述

stack_loop_n(n)：一个 stack 对象，循环 n 次入栈出栈
stack_thread_n_m(n, m)：同一个 stack 对象， n 个线程入栈和出栈，循环 m 次数据

结果对比

压测类型	总耗时	平均耗时
stack_loop_n(100000)	56.523467ms	565ns
list_loop_n(100000)	67.573497ms	675ns
stack_thread_n_m(2, 100000)	115.590207ms	577ns
list_thread_n_m(2, 100000)	161.359683ms	806ns
stack_thread_n_m(4, 100000)	440.585874ms	1.101µs
list_thread_n_m(4, 100000)	562.439723ms	1.406µs
stack_thread_n_m(8, 100000)	1.886768172s	2.358µs
list_thread_n_m(8, 100000)	2.120945074s	2.651µs

参考

Implementing Lock-Free Queues (1994)

https://gcc.gnu.org/onlinedocs/gcc/_005f_005fatomic-Builtins.html

https://lib.rs/crates/crossbeam-epoch

https://github.com/cppcoffee/stack-rs

Lock-Free Queues Implement

2021-03-25T00:00:00+00:00

Lock-Free Queues Implement

队列是一种FIFO的抽象数据结构，这里提到的无锁队列实现是 Implementing Lock-Free Queues(1994) 这篇论文提出来的。

无锁队列操作依靠 CPU 的 CAS (Compare And Swap) 指令，CAS 对应的 Intel CPU 指令是 lock cmpxchg，前缀 lock 表明这是一条原子操作指令。

现在许多新语言都有自带 CAS 相关函数；底层基础库也有提供内建函数，例如 GCC 提供的内建 CAS 函数：

bool __sync_bool_compare_and_swap (type *ptr, type oldval, type newval, ...)
type __sync_val_compare_and_swap (type *ptr, type oldval, type newval, ...)

队列结构体

实现无锁队列需要有两个指针：一个 head 指针，指向队列头部；一个 tail 指针，指向队列尾部。

节点结构体有一个 next 指针，指向下一个节点，形成链式队列。

// 队列节点结构体
typedef struct node_s  node_t;
struct node_s {
    node_t  *next;
    void    *value;
};

// 队列结构体
typedef struct queue_s  queue_t;
struct queue_s {
    node_t  *head;
    node_t  *tail;
};

初始化

论文提到初始化的时候生成一个 dummy 节点作为 head 和 tail 的初始值。

dummy 节点为了防止在空队列或只有一个节点的时候出现边界问题。

初始化的实现就如下：

int queue_init(queue_t *q)
{
    node_t *dummy = (node_t *) malloc(sizeof(node_t));

    if (dummy == NULL) {
        return -ENOMEM;
    }

    memset(dummy, 0, sizeof(node_t));

    q->head = q->tail = dummy;

    return 0;
}

函数中需要判断内存分配错误。

入队列

根据论文的伪代码实现如下：

int enqueue(queue_t *q, void *x)
{
    node_t  *node, *tail, *next;

    node = (node_t *) malloc(sizeof(node_t));
    if (node == NULL) {
        return -ENOMEM;
    }

    node->value = x;
    node->next = NULL;

    for ( ;; ) {
        tail = q->tail;
        next = tail->next;

        if (tail != q->tail) {
            continue;
        }

        if (next == NULL) {
            if (__sync_bool_compare_and_swap(&(tail->next), next, node)) {
                __sync_bool_compare_and_swap(&(q->tail), tail, node);
                return 0;
            }

        } else {
            __sync_bool_compare_and_swap(&(q->tail), tail, next);
        }
    }
}

出队列

出队列的实现会比较简单：

void *dequeue(queue_t *q)
{
    void    *v;
    node_t  *head, *tail, *next;

    for ( ;; ) {
        head = q->head;
        tail = q->tail;
        next = head->next;

        if (head != q->head) {
            continue;
        }

        if (head == tail) {
            if (next == NULL) {
                return NULL;
            }

            __sync_bool_compare_and_swap(&(q->tail), tail, next);

        } else {
            if (next == NULL) {
                continue;
            }

            v = next->value;

            if (__sync_bool_compare_and_swap(&(q->head), head, next)) {
                // FIXME: 释放会引发并发结构经典的 ABA 和内存回收问题
                //free(head);
                return v;
            }
        }
    }
}

ABA 问题

在多线程中，ABA 问题发生在同步期间，当一个位置被读取两次，两次读取的值都是一样的，“值是一样的”被用来表示“没有变化”。然而，另一个线程可以在两次读取之间执行，并改变值，做其他工作，然后把值改回来，从而欺骗第一个线程，使其认为“没有变化”，即使第二个线程所做的工作违反了这个假设：

T1 从共享内存中读取 A=Load(A) 后被暂停
T2 被调度执行
T2 修改共享内存 CAS(A, B) 将 A 修改成 B，并在被系统调度前 CAS(B, A） B 再被修改成 A
T1 再次被调度执行，从而看到 A 并没有被改变过

这需要保证内存不能立即释放（还有线程饮用它），也不能立即被重用，这就是无锁结构 CAS 最常见的坑，实际项目中，通常配合 128 位 CAS 来避免 ABA 问题，而支持 128 位 CAS 的硬件并不通用，所以需要做指针压缩(TaggedPointer)

Tagged Pointer

在 x86_64 机器上，指针高位地址用于在内核层表示，在应用层空间中就能够使用高位地址来作为 tag。

如下是 64 位长度的地址：

0000 0000 0000 0000

根据 linux mm 文档中描述，应用程序虚拟内存范围是 0000000000000000 - 00007fffffffffff

也就是说高 16 位是可以用来作为 tag.

0000 FFFF FFFF FFFF
^^^^
Free Data!

内存回收问题

在多线程操作中，内存不能直接释放，由于有其他线程在访问它，这样会造成 释放后访问 的问题：

T1 执行到 next = tail->next; 时被调度走 T2 执行 dequeue，将 tail 指向的内存释放 T1 再次被调度到，此时访问 tail->next 将造成内存释放后再访问的问题

这种情况需要保证内存访问的安全性，可以使用引用计数、hazard pointers 和 epoch based reclamation 等内存延迟回收算法。

Rust 实现

最后附上一版使用 Rust 实现无锁队列的完整代码，这里使用 crossbeam_epoch crate 来解决 ABA 问题和内存回收问题。

lib.rs

use std::sync::atomic::Ordering::{Acquire, Relaxed, Release};

use crossbeam_epoch::{self as epoch, Atomic, Owned, Shared};

unsafe impl<T: Send> Sync for Queue<T> {}

struct Node<T: Send> {
    next: Atomic<Node<T>>,
    data: Option<T>,
}

impl<T: Send> Node<T> {
    fn new(v: T) -> Self {
        Self {
            next: Default::default(),
            data: Some(v),
        }
    }

    fn sentinel() -> Self {
        Self {
            next: Atomic::null(),
            data: None,
        }
    }
}

pub struct Queue<T: Send> {
    head: Atomic<Node<T>>,
    tail: Atomic<Node<T>>,
}

impl<T: Send> Queue<T> {
    pub fn new() -> Self {
        let q = Queue {
            head: Atomic::null(),
            tail: Atomic::null(),
        };
        let sentinel = Owned::new(Node::sentinel());

        let guard = unsafe { &epoch::unprotected() };

        let sentinel = sentinel.into_shared(guard);
        q.head.store(sentinel, Relaxed);
        q.tail.store(sentinel, Relaxed);
        q
    }

    pub fn enq(&self, v: T) {
        unsafe { self.try_enq(v) }
    }

    unsafe fn try_enq(&self, v: T) {
        let guard = &epoch::pin();
        let node = Owned::new(Node::new(v)).into_shared(guard);

        loop {
            let p = self.tail.load(Acquire, guard);

            if (*p.as_raw())
                .next
                .compare_exchange(Shared::null(), node, Release, Relaxed, guard)
                .is_ok()
            {
                let _ = self.tail.compare_exchange(p, node, Release, Relaxed, guard);
                return;
            } else {
                let _ = self.tail.compare_exchange(
                    p,
                    (*p.as_raw()).next.load(Acquire, guard),
                    Release,
                    Relaxed,
                    guard,
                );
            }
        }
    }

    pub fn deq(&self) -> Option<T> {
        unsafe { self.try_deq() }
    }

    unsafe fn try_deq(&self) -> Option<T> {
        let guard = &epoch::pin();

        loop {
            let p = self.head.load(Acquire, guard);

            if (*p.as_raw()).next.load(Acquire, guard).is_null() {
                return None;
            }

            if self
                .head
                .compare_exchange(
                    p,
                    (*p.as_raw()).next.load(Acquire, guard),
                    Release,
                    Relaxed,
                    guard,
                )
                .is_ok()
            {
                let next = (*p.as_raw()).next.load(Acquire, guard).as_raw() as *mut Node<T>;
                return (*next).data.take();
            }
        }
    }
}

benchmark

lib.rs Queue 与标准库的 Mutex<LinkedList> 类型进行压测对比

压测代码

Queue 压测代码与 Mutex<LinkedList> 实现大同小异，不同的只是 enq 操作对应 push_front，deq 操作对应 pop_back。

这里贴两个 Queue 的压测相关代码，更多详细内容见文末的 queue-rs 仓库链接。

// n 次压测操作
fn queue_loop_n(n: u32) -> Duration {
    let q = Queue::new();
    let earler = Instant::now();

    for i in 0..n {
        q.enq(i as *mut u8);
    }
    for _ in 0..n {
        q.deq();
    }

    Instant::now().duration_since(earler)
}

// n 线程 + m 次操作
fn queue_thread_n_m(n: u32, m: u32) -> Duration {
    let mut handles = Vec::new();
    let elapsed = Arc::new(AtomicU64::default());

    for _ in 0..n {
        let q = Queue::new();
        let elapsed_clone = elapsed.clone();

        handles.push(thread::spawn(move || {
            let start = Instant::now();

            for i in 0..m {
                q.enq(i as *mut u8);
            }
            for _ in 0..m {
                q.deq();
            }

            let nanos = Instant::now().duration_since(start).as_nanos();
            elapsed_clone.fetch_add(nanos as u64, Ordering::SeqCst);
        }));
    }

    for handle in handles {
        handle.join().unwrap();
    }

    Duration::from_nanos(Arc::try_unwrap(elapsed).unwrap().into_inner())
}

结果对比

笔记本电脑 CPU 参数如下:

machdep.cpu.brand_string: Intel(R) Core(TM) i5-4278U CPU @ 2.60GHz
machdep.cpu.core_count: 2
machdep.cpu.thread_count: 4

备注: 领先的数据加黑标注

输出结果:

压测类型	总耗时	平均耗时
queue_loop_n(100000)	17.843828ms	178ns
list_loop_n(100000)	23.066353ms	230ns
queue_thread_n_m(2, 100000)	64.018836ms	320ns
list_thread_n_m(2, 100000)	74.660454ms	373ns
queue_thread_n_m(4, 100000)	149.736868ms	374ns
list_thread_n_m(4, 100000)	189.6352ms	474ns
queue_thread_n_m(8, 100000)	544.476377ms	680ns
list_thread_n_m(8, 100000)	980.688619ms	1225ns

参考

Implementing Lock-Free Queues (1994)

https://en.wikipedia.org/wiki/ABA_problem

https://gcc.gnu.org/onlinedocs/gcc/_005f_005fatomic-Builtins.html

Keir Fraser’s epoch-based reclamation

crossbeam-epoch crate

https://en.wikipedia.org/wiki/Tagged_pointer

https://www.kernel.org/doc/Documentation/x86/x86_64/mm.txt

https://github.com/cppcoffee/queue-rs

Thread Condition Signal 的两个陷阱

2021-02-27T00:00:00+00:00

Thread Condition Signal

当接触线程条件信号时，通常是实现生产者和消费者的场景。翻看 man 手册后，很疑惑为什么 cond 需要依赖外部的 mutex？

在 man 手册中没有 example 可以参考，很容易不假思索的写成下面这样子有陷阱的代码：

// producer
pthread_mutex_lock(&mutex);
pthread_cond_signal(&cond);
pthread_mutex_unlock(&mutex);


// consumer
pthread_mutex_lock(&mutex);
pthread_cond_wait(&cond, &mutex);
pthread_mutex_unlock(&mutex);

这样子写会步入 信号丢失的陷阱 中。

信号丢失的陷阱

当 signal 发生于 wait 之前，信号就会丢失

      +   +----------+    +----------+
      |   | producer |    | consumer |
      |   +----------+    +----------+
      |
      |   +----------+
      |   |   lock   |
      |   +----------+
      |   +----------+
      |   |  signal  |
      |   +----------+
Time  |   +----------+
      |   |  unlock  |
      |   +----------+
      |-------------------------------
      |                   +----------+
      |                   |   lock   |
      |                   +----------+
      |                   +----------+
      |                   |   wait   |
      |                   +----------+
      |                   +----------+
      |                   |  unlock  |
      v                   +----------+

这里是一个生产者，一个消费者的场景。 producer 优先执行，导致了信号丢失，consumer 一直在 wait 中。

虚假唤醒的陷阱

man pthread_cond_broadcast 文档中，Multiple Awakenings by Condition Signal 段落提到的 spurious wakeup 问题。

考虑到一个生产者，多个消费者的场景:

一个线程尝试等待条件变量，另一个线程并发执行到了 pthread_cond_signal，第三个线程已经在等待中。

如下伪代码实现与执行步骤(末尾数字)：

pthread_cond_wait(mutex, cond):
    value = cond->value; /* 1 */
    pthread_mutex_unlock(mutex); /* 2 */
    pthread_mutex_lock(cond->mutex); /* 10 */
    if (value == cond->value) { /* 11 */
        me->next_cond = cond->waiter;
        cond->waiter = me;
        pthread_mutex_unlock(cond->mutex);
        unable_to_run(me);
    } else
        pthread_mutex_unlock(cond->mutex); /* 12 */
        pthread_mutex_lock(mutex); /* 13 */


pthread_cond_signal(cond):
    pthread_mutex_lock(cond->mutex); /* 3 */
    cond->value++; /* 4 */
    if (cond->waiter) { /* 5 */
        sleeper = cond->waiter; /* 6 */
        cond->waiter = sleeper->next_cond; /* 7 */
        able_to_run(sleeper); /* 8 */
    }
    pthread_mutex_unlock(cond->mutex); /* 9 */

调用一次 pthread_cond_signal，导致了多个 consumer 线程在 pthread_cond_wait 或者 pthread_cond_timedwait 返回，这现象称为 spurious wakeup。

解决方法

当实现 Thread Condition Signal 逻辑时，外部的 mutex 锁是为了保证正确性，加入一个条件变量以保证唤醒信号不会丢失。

如下正确的写法：

// producer
pthread_mutex_lock(&mutex);
condition_ = true;
pthread_cond_signal(&cond, &mutex);
pthread_mutex_unlock(&mutex);


// consumer
pthread_mutex_lock(&mutex);
while (!condition_) {
    pthread_cond_wait(&cond);
}
condition_ = false;
pthread_mutex_unlock(&mutex);

如果是多个生产者多个消费者的情况，可以将条件改成 count 计数器。

参考

https://man7.org/linux/man-pages/man3/pthread_cond_broadcast.3p.html

https://code.woboq.org/userspace/glibc/nptl/pthread_cond_wait.c.html

Linux 文件碎片 top 工具 – Rust实现

2021-02-11T00:00:00+00:00

Linux 文件碎片 top 工具 – Rust实现

fragtop-rs

上一篇提到 Linux 下的 filefrag 工具的实现方式，可以用它来查看文件碎片，它没有提供一个扫描目录进行 top 碎片数量排序的功能，既然这样，那就动手做一个玩。

工具项目名为 fragtop-rs，寓意是跟 top 工具一样。fragtop-rs 能够根据 glob 匹配的文件进行碎片统计，并进行 top 排序输出。

fragtop-rs 采用 Rust 实现，Rust 有一个 fiemap 的 crate 可以使用 https://docs.rs/fiemap/，接口干净整洁，可以拿过来使用。

功能包括：需要指定 glob pattern，遍历匹配的文件进行碎片查询，最后给出 top-n 的列表。

Cargo.toml

首先创建项目，并进入项目目录中

% cargo new --bin fragtop-rs
     Created binary (application) `fragtop-rs` package

% cd fragtop-rs

需要的 crate 列表如下：

clap：用于命令行操作
glob：匹配文件路径
anyhow：错误处理
fiemap： Linux 文件碎片查找

逐个添加依赖的 crate

% cargo add clap
    Updating 'https://github.com/rust-lang/crates.io-index' index
      Adding clap v2.33.3 to dependencies

% cargo add glob
% cargo add anyhow
% cargo add fiemap

添加完 crate 后，Cargo.toml 的 dependencies 字段如下所示：

[dependencies]
clap = "2.33"
glob = "0.3"
anyhow = "1.0"
fiemap = "0.1"

逻辑实现

增加 clap 命令行处理，该工具需要 -p 参数来指定 glob pattern 路径和 -n 来指定 top-n 数量。

其中 -p 是要求必须指定；-n 默认值为 20，如果文件过多，就只显示 top 20 的文件

#[macro_use]
extern crate clap;

use clap::Arg;

fn main() -> anyhow::Result<()> {
    let matches = clap::app_from_crate!()
        .arg(
            Arg::with_name("path")
                .short("p")
                .help("Set the glob file path")
                .required(true)
                .takes_value(true),
        )
        .arg(
            Arg::with_name("top-n")
                .short("n")
                .help("Top fragment file")
                .default_value("20")
                .takes_value(true),
        )
        .get_matches();

    let path = matches.value_of("path").unwrap();
    let top_n = matches.value_of("top-n").unwrap().parse::<usize>()?;
    
    println!("path: {}, top: {}", path, top_n);
    
    Ok(())
}

运行输出：

% cargo run -- -p /tmp/
path: /tmp/, top: 20

输出结果正常，接下来要添加遍历匹配 glob pattern 的文件，并记录对应文件的碎片数量。

使用 BTreeSet<Tuple(fragments, path)> 来记录文件和它对应的碎片数量，BTreeSet 的好处是可以按照从小到大进行遍历，如果 rev() 则可以从大到小进行遍历。

...
use std::collections::BTreeSet;

fn main() -> anyhow::Result<()> {
    ...

    let mut records = BTreeSet::new();

    for entry in glob::glob(path)? {
        let entry = entry?;

        // 输出正在处理的文件
        // \r 开头则使用同一行进行替换输出
        print!("\rIn progress: {}", entry.display());

        // 获取文件碎片，并保存文件碎片数和文件路径
        let count = fiemap::fiemap(&entry)?.count();
        records.insert((count, entry));
    }

    Ok(())
}

已经有了文件路径和它对应的碎片数量，最后就是对这些信息的总结输出（遍历）。

fn main() -> anyhow::Result<()> {
...

    if records.len() == 0 {
        return Err(anyhow!("no files are scanned."));
    }

    println!("\nScan total file: {}", records.len());

    // rev() 倒序（从大到小），只取 take(top_n) 项
    for (count, entry) in records.iter().rev().take(top_n) {
        println!("{:<48}  {}", entry.display(), count);
    }

    Ok(())
}

以上，fragtop-rs 的代码完成了。

用它来查看 /var/log/ 目录下面的所有日志文件，并根据碎片数量输出

$ ./target/debug/fragtop-rs -p '/var/log/**/*'
In progress: /var/log/yum.log-20210101
Scan total file: 657
/var/log/access.log                               266
/var/log/wtmp                                     39
/var/log/messages-20210131                        22
/var/log/messages-20210207                        21
/var/log/messages-20210117                        20
/var/log/audit/audit.log.2                        20
/var/log/audit/audit.log.4                        19
/var/log/messages-20210124                        18
/var/log/audit/audit.log.1                        18
/var/log/nginx/access.log                         17
/var/log/audit/audit.log.3                        17
/var/log/cron-20210207                            14
/var/log/cron-20210131                            14
/var/log/cron-20210124                            14
/var/log/cron-20210117                            14
/var/log/messages                                 13
/var/log/audit/audit.log                          13
/var/log/yum.log-20200511                         10
/var/log/tuned/tuned.log                          10
/var/log/grubby                                   8

参考

https://docs.rs/fiemap/0.1.1/fiemap/

https://github.com/cppcoffee/fragtop-rs