• libshmcache源码阅读笔记

    引言

    由于在工作中需要开发一套内存缓存服务,使用了共享内存作为多进程间的数据共享。为了提高共享内存缓存服务的性能,我找了一个类似的较为成熟的开源项目 libshmcache ,通过研究源码学习其中的优点并改进自己的模块。

    libshmcache与redis相似的是都使用内存进行数据缓存;与redis不同的是,redis使用的进程自己申请的动态内存,而libshmcache使用的是共享内存。使用共享内存就意味着libshmcache主要的应用场景是同一台主机上的数据缓存。

    我花了一周时间阅读了比较感兴趣的部分代码,收获不少,现就以下几个方面总结一下自己的心得:

    • 纯C语言开发的代码风格
    • hash table的原理和实现
    • gcc原子化操作接口
    • 有锁写和无锁读的实现细节
    • 共享内存的两套函数接口(POSIX和SystemV)

    纯C语言开发时的代码风格

    我在工作中使用比较多的开发语言是C++,对于C语言编写的这样规模的项目,还是第一次仔细深入地研究。C语言使用 struct 作为大多数自定义数据结构的关键字,相对于C++能够使用成员函数能够对类进行功能拓展,C语言比较常用的是将这个对象作为输入参数传到函数中。

    纵观所有项目代码,我感受比较深的就是使用结构体中嵌套匿名结构体,这样做能够增强数据结构的层次感,示例代码如下:

    struct shmcache_context {
        pid_t pid;
        int lock_fd;    //for file lock
        int detect_deadlock_clocks;
        struct shmcache_config config;
        struct shm_memory_info *memory;
        struct {
    	struct shmcache_segment_info hashtable;
    	struct {
    	    int count;
    	    struct shmcache_segment_info *items;
    	} values;
        } segments;
    
        struct shmcache_value_allocator_context value_allocator;
        struct shmcache_list list;   //for value recycle
        bool create_segment;  //if check segment size                                  
    };
    

    注意 shmcache_context 中的匿名结构体 segmentsvalues ,这样的写法体现了相互包含关系,也使后续的操作该数据结构的语句更加容易理解。

    另外对于联合体和位域这两种技术也是我在之前开发中使用比较少的,通过阅读源码能够让我对其有了更深刻的理解。示例代码如下:

    union shm_hentry_offset {
        int64_t offset;
        struct {
    	int index :16;
    	int64_t offset :48;
        } segment;
    };
    

    这段代码使用了联合体赋予了 shm_hentry_offset 两种访问方式,又使用了位域将 int64_t 分割为两段。

    hash table的原理和实现

    libshmcache内部使用的是hash table做内部缓存的数据结构,这使查找的时间复杂度是O(1)。
    之前看过一些介绍hash table的资料,对hash table的工作原理是有过一个基础的了解的,这次通过阅读源码,能够了解到hash table在代码实现上更加细节的内容。
    对于hash计算中出现的hash值冲突,即在hash计算时出现了两个不同的key在经过hash计算后得到的bucket相同,libshmcache采用的解决方案是使用linked list来存放这些相同bucket对应的value。

    gcc原子化操作接口

    使用原子化操作接口能够解决一些并发读写问题,原子化操作相对于互斥锁执行更快。原子化操作也是一种无锁编程的方式。

    有锁写和无锁读的实现

    在libshmcache中,写操作通过 pthread_mutex_t 进行同步,而读操作是无锁的。
    对于写操作来说,需要对hash table进行操作,这肯定是需要同步的。
    pthread_mutex_t 保存在共享内存中,不同的进程通过映射共享内存就能获得同一个互斥量,通过这个互斥量就能完成进程间同步。

    共享内存的两套函数接口(POSIX和SystemV)

    在linux上使用共享内存时有两套接口 mmapshmgetmmapPOSIX 标准的接口,而 shmgetSystem V 标准的接口,两者都能够实现进程间共享内存,但他们在使用上还是有些区别的。对于 mmap 来说,需要在硬盘上创建一个文件,再将该文件映射到内存中。对于 shmget 来说,需要指定一个key,不同的进程通过相同的key就能映射到同一片内存。

  • C/C++中的位域

    1 什么是位域

    维基百科 给出了以下解释

    位域(或称“位段”,bit field)为一种数据结构,可以把数据以位的形式紧凑的储存,并允许程序员对此结构的位进行操作。

    cppreference 给出了以下定义

    Declares a class data member with explicit size, in bits. Adjacent bit field members may be packed to share and straddle the individual bytes.

    这种数据结构的好处:

    • 可以使数据单元节省储存空间,当程序需要成千上万个数据单元时,这种方法就显得尤为重要。
    • 位段可以很方便的访问一个整数值的部分内容从而可以简化程序源代码。

    而位域这种数据结构的缺点在于,其内存分配与内存对齐的实现方式依赖于具体的机器和系统,在不同的平台可能有不同的结果,这导致了位段在本质上是不可移植的。

    2 位域的语法

    identifier(optional) attr(optional) : size
    

    注意:

    • size的大小不能超过identifier所包含最大比特位个数。
    • identifier为空时表示对应的size个数的比特位不使用
    • size为0时表示根据前类型强制补齐
    struct S1 {
        // will usually occupy 2 bytes:
        // 3 bits: value of b1
        // 2 bits: unused
        // 6 bits: value of b2
        // 2 bits: value of b3
        // 3 bits: unused
        unsigned char b1 : 3, : 2, b2 : 6, b3 : 2;
    };
    
    struct S2 {
        // will usually occupy 2 bytes:
        // 3 bits: value of b1
        // 5 bits: unused
        // 6 bits: value of b2
        // 2 bits: value of b3
        unsigned char b1 : 3;
        unsigned char :0; // start a new byte
        unsigned char b2 : 6;
        unsigned char b3 : 2;
    };
    

    2.1 在size取0时如何理解

    对于size取0时的各种情况进行了尝试,详细用例如下。思路是使用联合体能比较方便地将内存分布表示出来。
    如下所示,定义了如下几种情况。

    2.1.1 case1

    union un1 {
        int n1;
        struct {
    	int nn1 : 4;
    	int : 0;
    	int nn2 : 16;
        } st;
    };
    

    对联合体中的结构体位段进行赋值,并将联合体中的内容打印出来。

    union un1 u1;
    u1.st.nn1 = 1;
    u1.st.nn2 = 1;
    printf("union u1.n1=0x%08x sizeof(un1)=%zu\n", u1.n1, sizeof(un1));
    

    输出结果为

    union un1.n1=0x00000001 sizeof(un1)=8
    

    2.1.2 case2

    union un1 {
        int n1;
        struct {
    	int nn1 : 4;
    	char : 0;
    	int nn2 : 16;
        } st;
    };
    

    输出结果为

    union un1.n1=0x00000101 sizeof(un1)=4
    

    2.1.3 case3

    union un1 {
        int n1;
        struct {
    	int nn1 : 4;
    	short : 0;
    	int nn2 : 16;
        } st;
    };
    

    输出结果为

    union un1.n1=0x00010001 sizeof(un1)=4
    

    2.1.4 case4

    union un1 {
        int n1;
        struct {
    	int nn1 : 8;
    	char : 0;
    	int nn2 : 16;
        } st;
    };
    

    输出结果为

    union un1.n1=0x00000101 sizeof(un1)=4
    

    2.2 struct 标识符

    多数例子都是以 struct 作为位域的组织标识,在C++中能否使用 class 作为位域的标识符。
    经过测试,是可以使用 class 的,但是需要注意 class 的默认访问控制属性为 private

    3 位域的常见应用场景

    为什么要使用位域?位域适合那些情况?
    位域的主要使用目的是节省对象的内存使用。在存放一些比较小的数据时,使用位域能够使字节中的每个比特位合理地利用起来,避免内存浪费。
    比较典型的应用是描述硬件寄存器。如果有32个一组的寄存器,每个寄存器代表一个比特位,就可以使用位域表示这组寄存器。

    4 C++中的位操作接口

    C++中也提供了一套位操作的接口 std::bitset ,这套接口提供了指定比特位数据的操作接口。

  • GCC的内存原子化操作函数接口

    1 原子化操作

    在并发编程中,一个操作或一组操作是原子操作、可线性化操作、不可分操作或不可中断操作(atomic, linearizable, indivisible, uniterruptible),表示该操作执行时不可被中断的。操作的原子性能够保证操作在执行时免受中断、信号、并发进程线程的影响。另外,原子操作大多只有两种结果,要么成功并改变系统中对应的状态,要么没有相关效果。

  • 在gdb中查看指定内存地址的内容

    调试 C/C++ 程序时,需要打印指定内存地址的内容。我最近调试程序中的序列化模块时,需要将类对象按照指定的格式转化为二进制流,为了验证转化结果,在调试时就需要将指定内存地址中的内容打印出来。

  • 同步和异步、阻塞和非阻塞

    1 同步和异步

    同步和异步指的是在进行I/O操作完成之前,是否允许其他处理步骤继续执行。
    计算机中的I/O操作相对于数据处理操作时十分耗时的。

    一个简单的I/O操作方式就是启动连接并等待操作完成,但是这样的操作(同步阻塞I/O)在通信过程中会阻塞进程的处理进度。
    相应的,可以在启动通信的同时进行其他的处理,并不需要等待I/O操作的完成,这样的操作就被称作是异步I/O。那些依赖于I/O操作执行完成的任务会阻塞等待I/O操作的完成,其他不依赖与I/O操作的任务能够继续执行。

    同步模型常用的函数接口: read , write , send , recv
    异步模型常用的函数接口: aio_write , aio_read

    1.1 POSIX AIO

    在头文件 aio.h 中定义,链接时使用 -lrt

    函数接口
    异步写操作

    int aio_read(struct aiocb* aiocbp);
    

    异步读操作

    int aio_write(struct aiocb* aiocbp);
    

    获取异步操作结果

    int aio_return(struct aiocb* aiocbp);
    

    获取异步操作中的错误

    int aio_error(struct aiocb* aiocbp);
    

    示例代码: github gist

    1.2 Linux AIO

    在头文件 libaio.h 中定义,链接时使用 -laio

    函数接口
    需要注意的是aio的函数接口需要借助 syscall 进行调用。
    创建aio context对象

    int io_setup(unsigned nr, aio_context_t* ctxp);
    

    销毁aio context对象

    int io_destroy(aio_context_t ctx);
    

    提交异步操作

    int io_submit(aio_context_t ctx, long nr, struct iocb** iocbpp);
    

    获取异步操作结果

    int io_getevents(aio_context_t ctx, long min_nr, long max_nr,
    		 io_event* events, struct timespec* timeout);
    

    示例代码:

    1.3 POSIX AIO与Linux AIO的区别

    摘自 stackoverflow.com

    On linux, the two AIO implementations are fundamentally different.
    The POSIX AIO is a user-level implementation that performs normal blocking I/O in multiple threads, hence giving the illusion that the I/Os are asynchronous. The main reason to do this is that:

    • it works with any filesystem
    • it works (essentially) on any operating system (keep in mind that gnu's libc is portable)
    • it works on files with buffering enabled (i.e. no ODIRECT flag set)

    The main drawback is that your queue depth (i.e. the number of outstanding operations you can have in practice) is limited by the number of threads you choose to have, which also means that a slow operation on one disk may block an operation going to a different disk. It also affects which I/Os (or how many) is seen by the kernel and the disk scheduler as well.
    The kernel AIO (i.e. iosubmit() et.al.) is kernel support for asynchronous I/O operations, where the io requests are actually queued up in the kernel, sorted by whatever disk scheduler you have, presumably some of them are forwarded (in somewhat optimal order one would hope) to the actual disk as asynchronous operations (using TCQ or NCQ). The main restriction with this approach is that not all filesystems work that well or at all with async I/O (and may fall back to blocking semantics), files have to be opened with ODIRECT which comes with a whole lot of other restrictions on the I/O requests. If you fail to open your files with ODIRECT, it may still "work", as in you get the right data back, but it probably isn't done asynchronously, but is falling back to blocking semantics.
    Also keep in mind that iosubmit() can actually block on the disk under certain circumstances.

    在Linux上两种AIO是完全不同的;
    POSIX AIO实现在用户层,实际上进行的操作是普通的多线程阻塞操作,表现为I/O操作是异步的,这种AIO的优点是兼容性和可移植性好,缺点是操作队列长度受限于最大线程数量。
    Linux AIO是内核提供的AIO函数接口,I/O操作请求的队列在内核中维护,这种AIO的缺点是并不支持所有的文件系统,Linux AIO在某些情况下的磁盘操作是会阻塞的。

    2 阻塞和非阻塞

    阻塞与非阻塞的概念针对的是函数是否会立即返回。
    非阻塞模型常与IO复用技术组合使用。
    可以通过函数将IO设备设置为非阻塞模式。

    3 如何理解阻塞非阻塞与同步异步的区别

    在处理 IO 的时候,阻塞和非阻塞都是同步 IO。
    只有使用了特殊的 API 才是异步 IO。

  • 查看Linux系统的相关信息

    查看Linux系统相关信息有助于排查和解决软件和硬件的兼容性问题。系统信息包括硬件信息和软件信息,硬件信息主要有CPU信息、内存信息、PCI信息、USB信息、硬盘信息等等。软件信息主要有系统版本、分区使用状态等等。本文主要介绍了获取当前Linux系统信息的命令。

    查看系统相关信息

    uname 指令提供了查询系统信息的功能,使用该命令能够快速获取操作系统信息概览。

    查看内核名称

    uname -s
    

    查看处理器类型

    uname -p
    

    查看硬件架构

    uname -i
    

    查看内核版本

    uname -r
    

    查看所有系统信息

    uname -a
    

    查看操作系统信息(发行版信息)

    cat /etc/os-release
    cat /proc/version
    lsb_release -a
    hostnamectl
    

    查看CPU相关信息

    lscpu 指令能够查看当前系统中CPU的详细信息,包括型号、主频、构架、大小端等信息。

    查看硬盘相关信息

    lsblk 指令能够查看块设备(block device)的详细信息,块设备主要指系统中的存储设备如硬盘和闪存。

    查看PCI设备的相关信息

    lspci 指令能够查看PCI设备的信息,PCI设备包括USB、显卡、串口、网卡等其他外围设备。

    输出树形结果

    lspci -t
    

    输出详细信息

    lspci -v
    lspci -vv
    

    查看USB设备的相关信息

    lsusb 指令能够查看USBS设备的信息。

    查看文件系统相关信息

    fdisk 命令能够查看和操作linux系统的分区表。

    查看文件系统信息

    fdisk -l
    

    df 命令能够查看分区信息和硬盘使用信息

    使输出信息更容易理解

    df -h