这是我无意中想到的一个方法，估计这个方法已经不是什么新鲜的东西了，很可能在类似的问题场景中早已经被使用了。不过这里还是要说说我的思维过程。

近期在学习一些Linux性能查看和分析方面的工具，比如top、iostat、vmstat以及sar等。在学习过程中我发现这些工具有个共同的特点，那就是她们采集的Linux运行数据都是从/proc下的文件中实时获取并计算而得出的。众所周知，/proc是Linux内核维护的一个虚拟文件系统，他允许用户在Linux运行时查看内核运行数据（用户可以像查看普通文件一样查看/proc下的目录和文件），甚至是运行时实时改变内核设置。Linux实现/proc的细节不是这里要关注的，吸引我的是Linux的这种提取运行数据的设计。这个设计将Linux运行数据的产生实现细节与第三方性能采集工具间的耦合最大化地解开，这样一来/proc就像是一种Linux的基础服务，为用户提供一种实时的运行数据信息。而用户侧的运行数据查看工具也可以根据用户的需求自由定制，因此有了top、iostat、vmstat、iotop、sar等关注点不同的工具。

好了，说完/proc后，再来说说我们的产品。用户长期以来一直在抱怨我们的产品监控和维护方面手段太过单一，产品就像是一个黑盒，没有提供一种自我运行观察的能力，让客户看不清阿看不清，用户无法实时获取当前某个节点上的业务运行状况，无法采集到这些业务运行的实时基础数据，这的确是我们长期以来的短板（以前这块受重视度也的确不足）。虽然这两年我们在改善运维手段方面的投入已经加大，并收到一些显著的效果，但方案都是集中的，且相对重量级的，不那么敏捷灵活 – 在单节点上依旧无法简单地获取该节点的运行数据。

结合/proc的设计以及我们所遇到的问题，我有了一个大胆的想法：是否可以给我们的业务系统也加上一种类似Linux /proc这样的可提供基础运行数据的服务能力呢？于是就有了下面的解决方法。

Linux /proc下面的数据文件是Linux Kernel维护的，并允许用户层的进程实时查看和配置数据。而对于我们的产品而言，提供基础数据的产品实例与提取基础数据的第三方程序是两个独立的用户level的进程，显然我们需要找到一种让这两个进程实时通信、低耦合的且性能代价极低的方法。

我首先想到的是文件，这似乎和/proc的方式一样。你查看一下sysstat源码会发现，像iostat、sar等工具都是用fopen以"r"方式打开/proc/下的各种stat文件，匹配和读取指标项后再统计的。但在User层，两个无亲缘关系进程共同操作一个文件 – 一个读，一个写，the file position indicator是很难控制的，可能涉及文件锁(flock/fcntl)，还要考虑使用的库函数是否是带缓冲的（fread/fgets都是带缓冲 的，不能用），写端需要及时fsync/fflush。总而言之，这么做是甚为自讨没趣的，会给两个程序的实现都带来很大的复杂性以及各种“坑”的。

那用named fifo如何呢？一但用named fifo，这两个进程就会产生启动依赖，如果一端没有启动，另一端会一直阻塞；而且通过fifo传递多种业务数据还可能存在打包和解包的过程，实现起来复杂的很。这显然是耦合十分严重的糟糕方案。

两个进程既要有共同的识别目标，就像/proc/cpuinfo这样的已知路径，一个进程还要能及时地得到另外一个进程运行时的数据，我们不妨尝试一下内存文件映射这个方案：运行数据提供的进程映射一个已知目标文件，比如perf/xxstat，然后在映射后的地址上创建和更新指标数据。比如我们建立一个整型数组，数组的每个元素都代表一种运行指标；而运行数据提取进程同样映射该文件，并在映射后获得数组中的各个元素值。下面是一个示例程序：

/* producer */
int
main()
{
    FILE *fp = NULL;

    errno = 0;
    fp = fopen(STAT_FILE, "w+");
    if (fp == NULL) {
        printf("can not create stat file , err = %d\n", errno);
        return -1;
    }

    errno = 0;
    long size = sysconf(_SC_PAGESIZE);
    if (ftruncate(fileno(fp), size) != 0) {
        printf("can not set stat file size, err = %d\n", errno);
        fclose(fp);
        return -1;
    }

    errno = 0;
    char *p = NULL;
    p = mmap(NULL, size, PROT_WRITE|PROT_READ, MAP_SHARED, fileno(fp), 0);
    if (p == MAP_FAILED) {
        printf("can not mmap file, error = %d\n", errno);
        fclose(fp);
        return -1;
    }

    errno = 0;
    if (fclose(fp) != 0) {
        printf("can not close file, error = %d\n", errno);
        return -1;
    }

    /* round up to 8 */
    while((int)p % 8 != 0) {
        p++;
    }

    long long *q = (long long*)p;
    q[0] = 1;
    q[1] = 1000;
    q[2] = 10000;
    q[3] = 100000;

    while(1) {
        q[0] += 1;
        q[1] += 10;
        q[2] += 100;
        q[3] += 1000;
        usleep(200);
    }

    return 0;
}

该producer程序首先尝试以"w+"方式打开xxstat文件，并设置文件的大小，然后调用mmap做内存文件映射，理论上来说mmap成功时返回的地址一定是按该平台下最严格内存系数对齐的地址，但这里为了安全起见，又做了一次内存地址的圆整。producer以映射的地址为首地址，建立了一个包含四个元素的、每个元素大小为8字节的整型数组，其中每个元素模拟一个运行指标。在while(1)循环中，producer模拟更新这四个指标数据。

下面是提取producer运行数据的例子程序，其映射过程与producer类似，这里就不贴出完整代码了，完整代码可在这里下载。

/* reader.c */

int
main()
{
    FILE *fp = NULL;
    … …

    char *p = NULL;
    p = mmap(NULL, size, PROT_READ,
             MAP_SHARED, fileno(fp), 0);
    if (p == MAP_FAILED) {
        printf("can not mmap file, error = %d\n", errno);
        fclose(fp);
        return -1;
    }

    … …

    long long *q = (long long*)p;

    while(1) {
        printf("%lld\t\t%lld\t\t%lld\t\t%lld\n", q[0], q[1], q[2], q[3]);
        sleep(1);
    }

    return 0;
}

在producer执行一段时间后，我们可以用reader去提取producer的实时运行数据了。

$ reader
2583        26820        268200        2682000
5793        58920        589200        5892000
9142        92410        924100        9241000
12431        125300        1253000        12530000
15586        156850        1568500        15685000
… …

需要注意的是两个进程映射的虽然是同一个文件，但各自进程空间映射的地址是不同的。如果在指标里存储地址数据，那另外一个进程在访问该地址时必然会出现问题。

在这个方案中，由于两个进程是读写同一块内存(虽然在各自进程空间的地址是不同的），因此数据是实时的。但由于两个进程间并没有任何同步机制，可能会产生误差，就好比一个进程中的两个线程对进程中某块地址空间一读一写这种情况一样。不过对于我们这种场景，这个问题是一般是可以被容忍和接受的，毕竟我们通过运行数据只是想了解一种运行趋势而已。如果producer中存在多个有亲缘关系的子进程或多线程要同时更新基础运行数据，那势必是要用锁或其他原子操作做数据操作的同步的。另外我们用的是内存映射具名的文件，OS会定期将数据刷到磁盘上，不过这个消耗对于小文件来说，对整体性能影响可忽略不计。

一旦业务系统具备了提供基础运行数据的能力，我们就可以根据我们的需求按照数据的格式打造我们所需要的各类数据提取和分析工具了。如果需要长期记录业务系统的运行情况，我们也可以实现类似sar这样的工具，以在后台定期对系统的运行数据进行记录，并提供历史查询等相关功能。

这种基于内存映射文件的方法还有一个好处，那就是我们可以用任何支持mmap调用的编程语言来实现数据提取工具，而不一定非得用C/C++这种原生适配Linux API的语言。

如果你觉得这种方案可行，那后续的重点就是基础运行数据的设计问题了。罗马不是一天建成的，/proc下的基础数据也不是一天就设计到位的。在基础数据设计这方面也是需要有很多考虑的，比如是文本还是二进制，用什么类型数据，还可能需要考虑一些数据对齐问题等。当然这就不是本文的重点了，就不细说了。

记得刚来公司时曾参与过一个项目，项目中用到了部门基础库中的一个B+树接口。不过在程序调试过程中我们发现可执行程序总是dump core（在sparc solaris上），经初步分析，断定问题就出在B+树接口处，但一时又找不到问题原因。还好这个B+树的实现者就坐在我的旁边。他分析后告诉我：这个B+树接口要求用户自定义的索引结构体的size应该为4的整数倍。按照他的说法，我为结构体打了padding，以满足结构体size为4的整数倍的要求。修改后果然不再dump core了。当时项目进度紧，我也没有求甚解，这件事也就过去了。

一晃N年过去了。今天在做程序的64位移植过程中我再次遇到了这个问题。问题的表象就是程序运行时dump core，通过gdb或pstack查看core的内容，发现程序是在B+ Tree初始化时出的core。显然这又是一个内存违规访问的问题，且在Sparc上出现（x86 Linux上运行正常）十有八九与内存对齐有关。

B+ Tree出问题首先让我想到了N年前的那个解决方法。我先查看了自定义的索引结构体(usr_idx)：

struct usr_idx {
    unsigned int usr;
};

不过sizeof(usr_idx)无论是32bit编译还是64bit编译，其值都是4。那按照B+树原作者的说法，这显然不足以让B+树出现问题。事实也的确如此，32bit编译的程序在Sparc Solaris下运行良好，只是目前改为了64bit编译，才dump core，那问题到底出现在哪呢？

到这里，我也只能从代码着手了，把N年前没弄清楚的原因找出来，顺便也把这个存在了N年的Bug彻底解决掉，把这笔技术债还了。pstack的输出告诉我问题出在一个名为bptree_create_node的函数中，嫌疑最大的一处代码大致是这样的：

for (i = 0; i rank; i++) {
    (elem_base(tree, tmp_bn, i))->key = key_base(tree, tmp_bn, i);
    (elem_base(tree, tmp_bn, i))->pointer = NULL;
}

直觉告诉我问题出在elem_base这个宏里，elem_base的定义如下：

#define elem_base(tree, eb, index) ((xx_bptree_elem*)((char *)&(eb)->e_base.mw_cp + ((SIZEOF_bptree_elem + (tree)->keysize))*(index)))

很显然这个定义最终是想得到一个xx_bptree_elem*类型的指针。从内存地址角度来说，我们会得到了一个内存地址，且这个地址被认为是一个xx_bptree_element元素的起始地址。那么是否所有地址作为xx_bptree_element元素的起始地址都合法呢？答案是不一定，至少在Sparc平台上不是所有地址都可以作为xx_bptree_elem的起始地址的。

那么什么样地址可以作为xx_bptree_element的起始地址呢？在Sparc上这取决于结构体的对齐系数。xx_bptree_elem结构的定义如下：

union mem_word {
    void  *mw_vp;
    void (*mw_fp)(void);
    char  *mw_cp;
    long   mw_l;
    double mw_d;
};
typedef union mem_word mem_word;
#define SIZEOF_mem_word (sizeof(mem_word))

struct xx_bptree_elem {
    void       *key;
    void       *pointer;
    mem_word   base;
};
typedef struct xx_bptree_item xx_bptree_item;
#define SIZEOF_bptree_elem        (sizeof(xx_bptree_elem)-sizeof(mem_word))

在32bit编译的情况下，系统默认对齐系数为4(参见/usr/include/sys/isa_defs.h中的宏_MAX_ALIGNMENT)，则该结构体的对齐系数 = min(max(sizeof(key), sizeof(pointer), sizeof(base)), 4) = 4。这样xx_bptree_elem在32bit下的有效起始地址为可被4整除的内存地址。

而在用64bit编译时，系统默认的对齐系数为16（同参见isa_defs.h），但由于xx_bptree_elem中size最大的字段(base)的size为8，则结构体的对齐系数就等于8。即xx_bptree_elem元素的有效起始地址为可被8整除的地址。

好了，我们再回过头来看看elem_base宏在不同编译情况下能否总是返回合法的地址。

#define elem_base(tree, eb, index) ((xx_bptree_elem*)((char *)&(eb)->e_base.mw_cp + ((SIZEOF_bptree_elem + (tree)->keysize))*(index)))

这个宏中有三个元素决定返回地址，分别是"基址"：&(eb)->e_base.mw_cp、偏移量SIZEOF_bptree_elem和(tree)->keysize。其中基址是另外一个结构体xx_bptree_node中一个mem_word类型字段的地址，你知道的，mem_word这种手法可以保证其起始地址严格按照其内部最大字段的对齐系数对齐的，也就是说mem_word的对齐系数与double的对齐系数一致，即无论是32bit编译还是64bit编译，其对齐系数都是8，也就是说我们可以确保这个”基址“是可以被8整除的；至于偏移量SIZEOF_bptree_elem，我们可以直接可以得出其大小：

32bit下，SIZEOF_bptree_elem = 8
64bit下，SIZEOF_bptree_elem = 16

可以看出无论是32bit还是64bit编译，SIZEOF_bptree_elem的值都是8的倍数；显然这两个值都不会影响elem_base最终返回地址的合法性。

现在剩下的就是(tree)->keysize了。keysize是由xx_bptree_init接口传进来的，它在上层实际上就是用户自定义的索引结构体的大小，显然这个大小不一定就是8的倍数。在我们的系统中，keysize = sizeof(usr_idx) =
4。这个keysize在32bit编译下是没有问题的，因为32bit编译只需要elem_base返回的地址可以被4整除即可，这也是为什么我们的程序在32bit编译下运行正常的原因。回想一下N年前的那个问题，其真正原因也就在这里：当时我定义的索引结构体的大小无法被4整除。在64bit编译下，keysize显然不能满足被8整除的要求，导致elem_base返回的地址只能被4整除。而xx_bptree_elem这个结构体的地址是严格要求必须可被8整除的。将一个只能被4整除而不能被8整除的地址强制转换为xx_bptree_elem元素地址并通过该强制类型转换后的地址访问xx_bptree_elem内部的元素显然就会导致core的出现了。

现在看来当初我的同事并未真正理解该B+ tree为何要求用户自定义结构体的大小必须为4的整数倍了，他只是通过现象得到了那条经验罢了，这笔技术债务也就从那时留了下来。

解决该问题并不难，作为基础库，我们无论如何都不应该依赖用户的自觉，我们在接口实现中增加一个转换就可以解决这一隐藏了若干年的Bug，将外面传入的keysize经align_word转换后再赋给tree->keysize，这样就可以保证elem_base始终返回合法的地址了。

突然想起了那句话：”出来混，总是要还的“，我们欠的技术债务也不例外。