IT博客-学而不思则罔，思而不学则殆-随笔分类-linux 编程

美团云计算方面面试题

易道 — Wed, 15 May 2013 02:52:00 GMT

1、Linux进程间的通信方式？两个进程是如何来共享内存的？两个进程如何通过信号量通信？

（1）Linux下进程间通信的方式有：管道(有名/无名) 、消息、信号、信号量、共享内存、邮箱、socket。

（2）Linux下共享内存是进程间通信的方式之一，共享内存允许两个或多个进程访问同一块内存，比如像 malloc函数向不同的进程返回执行同一块物理内存区域的指针。当一个进程改变了这块地址中的内容的时候，其他拥有这块物理内存指针的进程也会察觉到这个更改。在进程间的通信方式中，共享内存是通信效率最高的，访问共享内存区域和访问进程独有的内存区域一样快，并不需要通过系统调用或者其他通过内核的过程来完成，同时也避免了各种不必要的复制。对共享内存的操作涉及到多个进程间的同步问题，数据应该先写，在读，通常采用用信号量来协调这个过程。

进程与线程的区别？回答方式：

线程是进程中的一个逻辑执行单元，也是进程中可调度的实体；一个进程中可以包含多个线程，但是一个线程只能隶属于一个进程

与进程的区别：

1、CPU调度方面：CPU调度是以线程为基本单位进行的；

2、拥有资源方面：进程是拥有资源的基本单位，线程不拥有系统的资源，但是可以使用隶属于进程的资源；

3、并发方面：线程和进程都支持并发；

4、系统开销方面：创建进程的时候需要为进程分配资源，销毁进程时需要回收资源，所以使用进程的开销要大于使用线程的开销。

进程控制块?

操作系统通过进程控制块来对进程控制和管理的。PCB通常在系统内存中占用一块连续的分区，它存放着操作系统用于描述进程情况以及控制进程运行情况所需的全部信息，

为什么要CPU调度？

CPU调度的目标是在任何时候都有某些进程在运行，是CPU使用率最大化。同一时刻只有一个进程占有CPU资源，但一个进程在等待IO时等等一些阻塞进程的动作时，CPU就回空闲出来，这时候，我们应该让这个阻塞的进程让出CPU资源，让其他已经处于就绪状态的进程执行。这样就可以使CPU使用率最大化。

什么是死锁？

在多道程序环境下，多个进程可能竞争一定数量的资源，某个进程申请资源，如果这时这个资源不可用，那么这个进程就进入等待状态。如果所申请的资源被其他等待进程占有，那么该等待进程可能再也无法改变其状态，一直等待下去，这种情况称之为死锁。

cache的作用？

cache是处于 CPU寄存器和内存之间的一层缓存，用来加快CPU的取指速率，使用时： CPU需要数据时，首先会查找cache中有没有需要的数据，如果有，则取走，如果没有，则查询内存，并将数据更新到缓存中，以供下次取指。

2、DNS (Domain name system)域名系统，简单描述其工作原理。

DNS客户机需要在程序中使用名称时，它会查询DNS服务器来解析该名称。客户机发送的每条查询信息包括三条信息：包括：指定的DNS域名，指定的查询类型，DNS域名指定的类别。它是基于UDP的服务，端口是53，该应用一般不直接为用户使用，而是为其他应用服务如 HTTP、SMTP等在其中需要完成主机名到IP地址转换。

在浏览器地址栏内敲 www.baidu.com 到这个页面显示在浏览器上，这个过程中都发生了什么？

（1）当我们在浏览器上敲入一个url是，浏览器会解析出该url的域名，接下来的动作，是将域名转化为 ID 地址，依次查询浏览器DNS缓存、系统缓存、路由器缓存、如果没有找到则一直查询到根域名服务器缓存，找到域名所对应的的 IP地址。

（2）向IP所对应的的服务器发送请求数据，

（3）服务器响应请求，发回网页内容；

（4）客户端浏览器获取网页内容，解析，并显示在浏览器上。

这就是我们所看到的的百度页面显现的过程。

3、TCP/UDP的区别？

（1）TCP是面向连接的、可靠数据传输协议，UDP是不面向连接的，非可靠数据传输协议；（2）从传输速度上考虑： TCP 由于要建立连接、保证数据传输的可靠性等造成数据传输速度比较慢，UDP不需要这些，数据传输速度相对比较快；（3）从安全方面考虑，TCP的安全性能更高，UDP的安全性能比较低（4）从传输数据的格式来比较，TCP传输的单位称为报文段，UDP传输的数据单位被称为数据报

4、ICMP协议

ICMP (Internet Control Message Protocol) ，因特网控制消息协议。它是TCP/IP协议族的一个子协议，用于在IP主机、路由器之间传输控制消息。控制消息包括：网络不同、主机是否可达、路由器是否可用等网络本身的消息。这些控制消息虽然并不传输用户数据，但对用户数据的传递起着很重要的作用。ICMP报文格式两种：差错报告报文和询问报文。

5、数据库

数据库一个逻辑执行单元如何才能被称的上是一个事务？必须满足的性质？

数据库的事务是指一个逻辑单元，这个逻辑单元可包含一系列的执行操作，一个逻辑单元要想成为一个事务，必须满足所谓的 ACID （原子性、隔离性、一致性、持久性）；

原子性：指的是一个事务执行，要么全部执行成功，要么执行失败回滚到执行之前的状态；

一致性：事务执行过后，数据库中数据的状态都必须是一致的，必须遵从数据库的完整性约束；

隔离性：对于多个事务并发的时候，

持久性：事务的完成后对系统的影响是持久的，任何一个事务的操作不会对其他事务造成干扰；比如一个事务在读数据库，一个事务在写数据库，读数据库的这个事务读到的数据，要么是这个写数据库事务写前的状态，要么为写后的状态，不存在读到的数据是另一个事务写的过程中的一个状态。

数据库索引？

6、内存管理

内存的段页式管理的优缺点？

分段：

在段式存储管理中，将程序的地址空间（进程地址空间）划分为若干个段(segment)，这样每个进程都有一个二维的地址空间，相互独立，互不干扰。程序通过分段来划分为多个模块，如代码段、数据段、共享段等，这样做的优点是：可以分别编译源程序的一个文件，并且可以针对不同类型的段采取不同的保护，也可以按段为单位进行共享。段式存储管理的优点是：没有内碎片，外碎片可以通过内存紧缩来消除，便于实现内存共享。

分页：将程序的逻辑地址空间划分为固定大小的页 (page)，而物理内存划分为同样大小的页框(pageframe)。程序加载时，可以将任意一页放入内存中的任意一个页框，这些页框不必连续，从而实现了离散分配。这种管理的优势是：没有外碎片，且一个程序不必连续存放，这样就便于更改程序占用的空间大小。

页式和段式系统有许多相似之处，比如，两者都采用离散的分配方式，都通过地址映射机构来实现地址变换。但概念上两者是有很多区别的，主要表现在：

[1]、页是信息的物理单位，段是信息的逻辑单位，每个逻辑单元分为一个段。

[2]、页大小固定由系统决定，把逻辑地址划分为页号和页内地址两部分，段的长度不固定，且决定于用户编写的程序

[3]、页式系统地址空间是一维的，即为单一的线性地址空间，程序员只需利用一个标识符，即可表示一个地址。分段的作业地址空间是二维的，程序员在标识一个地址时，既需给出段名，又需给出段内地址。

http://dongxicheng.org/os/linux-memory-management-basic/

内存：

（1）虚拟内存：计算机系统内存管理的一种技术。它使得应用程序认为它拥有连续可用的内存（一块连续完整的地址空间），而实际上，他/她通常被分割成多个物理内存碎片，还有部分占时存储在外部磁盘存储器上，在需要时进行交换数据。与没有虚拟内存技术的系统相比，使用这种技术的系统使得大型程序编写变得更容易，对真正的物理内存使用的更有效率。

（2）物理内存：实际的内存，物理地址被分成离散的单元，称为页，页面大小是跟操作系统的位数有关系，一般为4K

7、程序内存分区

5个分区：

堆区：用户在这进行动态内存分配区，

栈区：系统自动分配，自动回收，速度快，效率高，但是栈区比较小，小心栈溢出

全局区：存储全局变量和静态变量，

文字常量区：常量字符串就存储在这，程序结束后，由系统同一释放。

程序代码区：存放程序的二进制代码。

易道 2013-05-15 10:52 发表评论

Linux 串口编程主要代码

易道 — Fri, 22 Mar 2013 03:57:00 GMT

摘要: Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/--> 1#include ... 阅读全文

易道 2013-03-22 11:57 发表评论

[转]在Linux下产生并调试core文件

易道 — Wed, 05 Mar 2008 04:09:00 GMT

转载自: http://blog.china-pub.com/more.asp?name=uniware&id=35478

uname -a
Linux dev 2.4.21-9.30AXsmp #1 SMP Wed May 26 23:37:09 EDT 2004 i686 i686 i386 GNU/Linux

再看看默认的一些参数，注意core file size是个0，程序出错时不会产生core文件了。

$ ulimit -a
core file size (blocks, -c) 0
data seg size (kbytes, -d) unlimited
file size (blocks, -f) unlimited
max locked memory (kbytes, -l) 4
max memory size (kbytes, -m) unlimited
open files (-n) 2048
pipe size (512 bytes, -p) 8
stack size (kbytes, -s) 10240
cpu time (seconds, -t) unlimited
max user processes (-u) 7168
virtual memory (kbytes, -v) unlimited

写个简单的程序，看看core文件是不是会被产生。

$ more foo.c

#include

static void sub(void);

int main(void)
{
sub();
return 0;
}

static void sub(void)
{
int *p = NULL;

/* derefernce a null pointer, expect core dump. */
printf("%d", *p);
}

$ gcc -Wall -g foo.c
$ ./a.out
Segmentation fault

$ ls -l core.*
ls: core.*: No such file or directory

没有找到core文件，我们改改ulimit的设置，让它产生。1024是随便取的，要是core文件大于1024个块，就产生不出来了。

$ ulimit -c 1024

$ ulimit -a
core file size (blocks, -c) 1024
data seg size (kbytes, -d) unlimited
file size (blocks, -f) unlimited
max locked memory (kbytes, -l) 4
max memory size (kbytes, -m) unlimited
open files (-n) 2048
pipe size (512 bytes, -p) 8
stack size (kbytes, -s) 10240
cpu time (seconds, -t) unlimited
max user processes (-u) 7168
virtual memory (kbytes, -v) unlimited

$ ./a.out
Segmentation fault (core dumped)
$ ls -l core.*
-rw------- 1 uniware uniware 53248 Jun 30 17:10 core.9128

注意看上述的输出信息，多了个(core dumped)。确实产生了一个core文件，9128是该进程的PID。我们用GDB来看看这个core。

$ gdb --core=core.9128
GNU gdb Asianux (6.0post-0.20040223.17.1AX)
Copyright 2004 Free Software Foundation, Inc.
GDB is free software, covered by the GNU General Public License, and you are
welcome to change it and/or distribute copies of it under certain conditions.
Type "show copying" to see the conditions.
There is absolutely no warranty for GDB. Type "show warranty" for details.
This GDB was configured as "i386-asianux-linux-gnu".
Core was generated by `./a.out'.
Program terminated with signal 11, Segmentation fault.
#0 0x08048373 in ?? ()
(gdb) bt
#0 0x08048373 in ?? ()
#1 0xbfffd8f8 in ?? ()
#2 0x0804839e in ?? ()
#3 0xb74cc6b3 in ?? ()
#4 0x00000000 in ?? ()

此时用bt看不到backtrace，也就是调用堆栈，原来GDB还不知道符号信息在哪里。我们告诉它一下：

(gdb) file ./a.out
Reading symbols from ./a.out...done.
Using host libthread_db library "/lib/tls/libthread_db.so.1".
(gdb) bt
#0 0x08048373 in sub () at foo.c:17
#1 0x08048359 in main () at foo.c:8

此时backtrace出来了。

(gdb) l
8         sub();
9         return 0;
10     }
11
12     static void sub(void)
13     {
14         int *p = NULL;
15
16         /* derefernce a null pointer, expect core dump. */
17         printf("%d", *p);
(gdb)

易道 2008-03-05 12:09 发表评论

[转]用gdbserver调试共享库.txt

易道 — Wed, 05 Mar 2008 03:34:00 GMT

在开发嵌入式系统时，调试往往是一大难题。面试过不少嵌入式linux工程师，当问及调试手段时，他们的调试手段一般是两种：首先是在PC上的模拟环境中运行，若有问题，可以很方便的调试。其次，若在板子上运行时才出错，就用printf输出log信息，根据log信息定位错误。有少部分人用gdbserver调试板子上的程序，但问到如何在共享库里设置断点时，都说没有办法。

    去年，Tinyx的一个内存越界BUG，花了我2天时间。gcc的一个浮点数BUG让我查了3天时间。这类BUG在PC上根本重现不了，在板子上用printf要花费大量的时间才能把错误的范围缩小一点。后来想了想，与其花时间去加printf，还不如把gdbserver调试共享库的问题解决了，可以为以后的调试节省不少时间。

    在网上找了半天资料，没有什么收获，看来只好自己动手研究。花了一个周末的时间去研究gdbserver的运行方式。办法是找到了，不过仍然有点麻烦，等有时间了，修改一下gdb的代码，把这个过程自动化了。

    先调试运行gdbserver，对gdbserver有了一些感性认识，然后研究linux-low.c中的代码。原来，设置断点只是在对应的内存中写入断点指令（x86上为0xcc）。

    gdbserver为什么不能在共享库中设置断点呢？设置断点只是写内存，调试时，所有的代码段都是可写的，在exe中可以设置断点，没有理由不让在共享库中设置啊。所以这应该与是否是共享库关系不大。

    猜测可能是符号与地址对应关系有误，如果你的本意为function1设置断点，结果gdb搞错了，设置一个毫不相干的地方，可能永远都不会执行到那里，这个断点自然没什么效果。

    如果是这样，有两种方法可以解决：要么手动计算符号的地址，再设置断点，当然这样太累。另外就让gdb自动对应起来。经过反得尝试，用下列方法可以在共享库中设置断点，虽然有点麻烦，还是可行的。

1. 准备工作，编写下面几个文件：

test.c:
#include
int test(int a, int b)
{
int s = a + b;
printf("%d\n", s);
return s;
}

main.c:
#include
extern int test(int a, int b);
int main(int argc, char* argv[])
{
int s = test(10, 20);
return s;
}

Makefile:
all: so main
so:
gcc -g test.c -shared -o libtest.so
main:
gcc -g main.c -L./ -ltest -o test.exe
clean:
rm -f *.exe *.so

（为了便于演示，整个过程在PC上测试，后来证实在实验板上能够正常工作）

2. 编译并设置环境变量
make
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:./

3. 运行gdbserver
gdbserver localhost:2000 ./test.exe

4. 运行gdb客户端
gdb
symbol-file test.exe
target remote localhost:2000
b main
c

5. 查看libtest.so的代码在内存中的位置。
（从gdbserver的输出或者用ps可以得到test.exe的进程ID，这里假设PID是11547）
cat /proc/11547/maps
输出：

00624000-0063e000 r-xp 00000000 03:01 718192 /lib/ld-2.3.5.so
0063e000-0063f000 r-xp 00019000 03:01 718192 /lib/ld-2.3.5.so
0063f000-00640000 rwxp 0001a000 03:01 718192 /lib/ld-2.3.5.so
00642000-00766000 r-xp 00000000 03:01 718193 /lib/libc-2.3.5.so
00766000-00768000 r-xp 00124000 03:01 718193 /lib/libc-2.3.5.so
00768000-0076a000 rwxp 00126000 03:01 718193 /lib/libc-2.3.5.so
0076a000-0076c000 rwxp 0076a000 00:00 0
00bbe000-00bbf000 r-xp 00bbe000 00:00 0
00fcc000-00fcd000 r-xp 00000000 03:01 1238761 /root/test/gdbservertest/libtest.so
00fcd000-00fce000 rwxp 00000000 03:01 1238761 /root/test/gdbservertest/libtest.so
08048000-08049000 r-xp 00000000 03:01 1238765 /root/test/gdbservertest/test.exe
08049000-0804a000 rw-p 00000000 03:01 1238765 /root/test/gdbservertest/test.exe
b7f8a000-b7f8b000 rw-p b7f8a000 00:00 0
b7f99000-b7f9a000 rw-p b7f99000 00:00 0
bfd85000-bfd9a000 rw-p bfd85000 00:00 0 [stack]

由此可以知道：libtest.so的代码在00fcc000-00fcd000之间。

6. 查看libtest.so的.text段在内存中的偏移位置：
objdump -h libtest.so |grep .text
输出：
9 .text 00000130 00000450 00000450 00000450 2**4
即偏移位置为0x00000450

7. 回到gdb窗口，加载libtest.so的符号表。
add-symbol-file libtest.so 0x00fcc450
(这里0x00fcc450 = 0x00fcc000 0x00000450)

8. 在共享库的函数中设置断点。
b test

9. 继续调试，可以发现在共享库中设置的断点，能够正常工作。
这个方法仍然有点麻烦，写在这里算抛砖引玉吧，望大家不吝赐教，谢谢。

http://www.dzkf.cn/html/qianrushixitong/2007/0626/2293.html

易道 2008-03-05 11:34 发表评论

转，基于英文单词的快速HASH索引算法。

易道 — Mon, 02 Jul 2007 01:32:00 GMT

因为有项目需要，要做一个类似ispell 的软件，其中会产生大量的对单词的查找操作，于是经过一翻研究，得出以下HASH算法，经过验证比一般的查表的FNV HASH算法产生的分布曲线基本没什么两样，并且在大部分的不同字典下，本算法要比查表的FNV HASH算法表现出速度更快，分布更均匀。但是因为是实验结果，所以暂时还没得出有效的数学推论，但是从大量的不同的字典测试数据来看，此算法确实效率不错。

由于以前没有涉及过相关的纯算法的设计，所以刚刚开始的时候，打算随便选用一种HASH，比如说用%除大质数，然后借此搭建一个比较强壮的测试环境，然后打算根据测试结果来改进HASH算法的模型。

最开始，我的HASH函数是这样的：
unsigned int hash_func(char *str, int len)
{
     register unsigned int sum = 0;
     register char *p = str;

     while(p - str < len)
          sum += *(p++);

     return sum % MAX_PRIME_LESS_THAN_HASH_LEN;
}
非常简单，但是这是绝对不可取的，通过这个函数，我选取了一个23w词的字典做为测试，当HASH SIZE=1024的时候，得到了以下的图象：

看得出震荡幅度相当大，那么如何来改进呢？首先想到可能产生的冲突的是这种情况：abcd和acbd，对于这两种单词来说，如果用上面的HASH函数，就一定会发生碰撞，为什么呢？因为每个字符少了关于它自己的位置信息，于是第一次改进版本的HASH函数就给每个字符加上了它的位置信息，将上面所描述的函数改进为：

unsigned int hash_func(char *str, int len)
{
     register unsigned int sum = 0;
     register char *p = str;

     while(p - str < len)
          sum += *(p++) * (p–str);

     return sum % MAX_PRIME_LESS_THAN_HASH_LEN;
}
得到以下图象：

某种程度上来说，比不带位置信息产生的分布图要好多了，但是仍然非常的不均匀。那么接来分析产生分布不均匀的原因，因为是用的乘法，所以仍然太过于依赖字母产生的结果了。于是改用XOR操作，选用以下函数：

unsigned int hash_func(char *str, int len)
{
     register unsigned int sum = 0;
     register char *p = str;

     while(p - str < len)
          sum += (*(p++) * (p–str)) ^ sum;

     return sum % MAX_PRIME_LESS_THAN_HASH_LEN;
}
得到以下图象：

上图虽然震荡幅度比较，不过做出来的regression line明显比上两张图片平得多了。但是结果仍然非常不好，从800到100的range太大。原因还是因为数据分布得不够均匀，于是思考单独的用加法来算是不是不太好，根据其他查表类HASH算法的过程，发现其大多都用了高低位来组合成最后的结果，于是我也采用了他们的方法：

unsigned int hash_func(char *str, int len)
{
     register unsigned int sum = 0;
     register unsigned int h = 0;
     register char *p = str;

     while(p - s < len)
     {
          register unsigned short a = *(p++);
          sum ^= a * (p - str);
          h ^= a / (p - str);
     }
     return ((sum << 16) | h) % MAX_PRIME_LESS_THAN_HASH_LEN;
}

得到最终近似完美的图象：

最后得出结论，不用查表的方法，而通过字符串本身的位置对字符本身进行修正的方法也能得到结果相当满意的HASH函数，之后换了几个大小不同的字典进行测试，得出的图象都大致和上图一致，非常令人满意。对于这个项目，包括如何检查单词错误，和自动修正等等相关的内容，会随着项目的完成一一在整理成文档，希望大家支持。

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=167909

易道 2007-07-02 09:32 发表评论

若干经典的字符串哈希函数

易道 — Mon, 02 Jul 2007 01:17:00 GMT

摘要: // RS Hash Function unsigned int RSHash( char * str) { unsigned int b = 378551 ; ... 阅读全文

易道 2007-07-02 09:17 发表评论

C语言中用bsearch()实现查找操作

易道 — Tue, 19 Jun 2007 03:18:00 GMT

C语言中可以用bsearch()实现二分查找。同qsort()一样，bsearch()也包含在库中，且同样要自定义比较子函数。其原型如下：

void *bsearch(const void *key, const void *base, size_t nmem, size_t size, int (*comp)(const void *, const void *));

key指向所要查找的元素，base指向进行查找的数组，nmem为查找长度，一般为数组长度，size为每个元素所占的字节数，一般用sizeof(...)表示，comp指向比较子函数，它定义比较的规则。需要注意的是，数据必须是经过预先排序的，而排序的规则要和comp所指向比较子函数的规则相同。如果查找成功则返回数组中匹配元素的地址，反之则返回空。对于有多于一个的元素匹配成功的情况，bsearch()未定义返回哪一个。

例：

#include #include #define NUM 8 int compare(const void *p, const void *q) { return (*(int *)p - *(int *)q); } int main(int argc, char *argv[]) { int array[NUM] = {9, 2, 7, 11, 3, 87, 34, 6}; int key = 3; int *p; qsort(array, NUM, sizeof(int), compare); p = (int *)bsearch(&key, array, NUM, sizeof(int), compare); (p == NULL) ? puts("not found") : puts("found"); return 0; }

结果如下：

found

易道 2007-06-19 11:18 发表评论

c语言和脚本编程

易道 — Tue, 29 May 2007 09:43:00 GMT

#include
#include
#include
#include
#include

int main()
{
#define RECV_BUF   1024
   int fd[2] ;
    char _recv_buf[RECV_BUF   ] ;
    memset(_recv_buf,0, RECV_BUF   ) ;

   if(pipe(fd))
   {
        return -1 ;
   }

将输出于写管道建立关联, system的屏幕输出到fd[1], ,可以在fd[0] 读取数据
   close(1) ;
    dup2(fd[1] ,1) ;
   close(fd[1]) ;

   //sed -n '/eth0/p' /proc/net/dev | awk '{print $1, $2}' | sed -n 's/eth0://p
   // mpstat | sed -n '$p'| awk '{print $9}'

   system("sed -n '1,2p' /proc/meminfo |awk '{print $2} '") ;
    // 从读管道读入数据
   read(fd[0], _recv_buf, RECV_BUF);

    // 显示到屏幕
write(2 , _recv_buf, strlen(_recv_buf)) ;

    // 关闭读管道
   close(fd[0]) ;

   return 0 ;
}

易道 2007-05-29 17:43 发表评论

Linux 内存调试工具- Valgrind 使用初探

易道 — Fri, 20 Apr 2007 09:58:00 GMT

Valgrind 是在linux系统下开发应用程序时用于调试内存问题的工具。它尤其擅长发现内存管理的问题，它可以检查程序运行时的内存泄漏问题。

它的官方网址是 http://www.valgrind.org/

下载最新版本的Valgrind，目前是3.2.0。 wget http://www.valgrind.org/downloads/valkyrie-1.2.0.tar.bz2

执行常规的安装步骤：./confgure && make && make install。注意：系统必须安装QT的开发包。即便这样在make 时还是出现qplatformdefs.h这个文件找不到的情况，导致make失败。查找系统中的qplatformdefs.h 之后，发现没有存在于qt的标准头文件目录/usr/lib/qt-3.3/include。如是将/usr/lib/qt- 3.3/mkspecs/linux-g++/ 目录下该头文件复制标准头文件目录，重新make ，后面一切OK。

初次使用

    编译如下代码:  gcc -Wall example.c -g -o example

#include 

void f(void)
{
   int* x = malloc(10 * sizeof(int));
   x[10] = 0;        // problem 1: heap block overrun
}                    // problem 2: memory leak -- x not freed

int main(void)
{
     f();
     return 0;
}

注意：gcc 的-g 选项让Valgrind调试输出时指出相应信息的代码所在的行号。

valgrind --tool=memcheck --leak-check=yes ./example

==6742== Memcheck, a memory error detector for x86-linux.
==6742== Copyright (C) 2002-2004, and GNU GPL'd, by Julian Seward et al.
==6742== Using valgrind-2.2.0, a program supervision framework for x86-linux.
==6742== Copyright (C) 2000-2004, and GNU GPL'd, by Julian Seward et al.
==6742== For more details, rerun with: -v
==6742==
==6742== Invalid write of size 4
==6742==    at 0x8048384: f (example.c:6)
==6742==    by 0x80483AC: main (example.c:12)
==6742== Address 0x1B908050 is 0 bytes after a block of size 40 alloc'd
==6742==    at 0x1B904984: malloc (vg_replace_malloc.c:131)
==6742==    by 0x8048377: f (example.c:5)
==6742==    by 0x80483AC: main (example.c:12)
==6742==
==6742== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 12 from 1)
==6742== malloc/free: in use at exit: 40 bytes in 1 blocks.
==6742== malloc/free: 1 allocs, 0 frees, 40 bytes allocated.
==6742== For counts of detected errors, rerun with: -v
==6742== searching for pointers to 1 not-freed blocks.
==6742== checked 1360800 bytes.
==6742==
==6742==
==6742== 40 bytes in 1 blocks are definitely lost in loss record 1 of 1
==6742==    at 0x1B904984: malloc (vg_replace_malloc.c:131)
==6742==    by 0x8048377: f (example.c:5)
==6742==    by 0x80483AC: main (example.c:12)
==6742==
==6742== LEAK SUMMARY:
==6742==    definitely lost: 40 bytes in 1 blocks.
==6742==    possibly lost:   0 bytes in 0 blocks.
==6742==    still reachable: 0 bytes in 0 blocks.
==6742==         suppressed: 0 bytes in 0 blocks.
==6742== Reachable blocks (those to which a pointer was found) are not shown.
==6742== To see them, rerun with: --show-reachable=yes

上面的C程序存在两个错误：1. 数组下标越界；2. 分配的内存没有释放，存在内存泄露的问题。对于错误1，看Valgrind的调试信息片断

==6742== Invalid write of size 4
==6742==    at 0x8048384: f (example.c:6)
==6742==    by 0x80483AC: main (example.c:12)
==6742== Address 0x1B908050 is 0 bytes after a block of size 40 alloc'd
==6742==    at 0x1B904984: malloc (vg_replace_malloc.c:131)
==6742==    by 0x8048377: f (example.c:5)

对于错误2，看这个

==6742== malloc/free: 1 allocs, 0 frees, 40 bytes allocated.

......

==6742== 40 bytes in 1 blocks are definitely lost in loss record 1 of 1
==6742==    at 0x1B904984: malloc (vg_replace_malloc.c:131)
==6742==    by 0x8048377: f (example.c:5)
==6742==    by 0x80483AC: main (example.c:12)

转 Linux 2.6内核中提高网络I/O性能的新方法-epoll

易道 — Wed, 18 Apr 2007 08:36:00 GMT

inux 2.6内核中提高网络I/O性能的新方法-epoll

2007-04-11 18:52

前一阵和同事讨论监控的时候，有同事提出用epool的方式管理线程，为了增长知识查找了一下资料：

1、为什么select是落后的？
首先，在Linux内核中，select所用到的FD_SET是有限的，即内核中有个参数__FD_SETSIZE定义了每个FD_SET的句柄个数，在我用的2.6.15-25-386内核中，该值是1024，搜索内核源代码得到：
include/linux/posix_types.h:#define __FD_SETSIZE 1024
也就是说，如果想要同时检测1025个句柄的可读状态是不可能用select实现的。或者同时检测1025个句柄的可写状态也是不可能的。
其次，内核中实现select是用轮询方法，即每次检测都会遍历所有FD_SET中的句柄，显然，select函数执行时间与FD_SET中的句柄个数有一个比例关系，即select要检测的句柄数越多就会越费时。
当然，在前文中我并没有提及poll方法，事实上用select的朋友一定也试过poll，我个人觉得select和poll大同小异，个人偏好于用select而已。

2、2.6内核中提高I/O性能的新方法epoll

epoll是什么？按照man手册的说法：是为处理大批量句柄而作了改进的poll。要使用epoll只需要这三个系统调用：epoll_create(2)， epoll_ctl(2)， epoll_wait(2)。
当然，这不是2.6内核才有的，它是在2.5.44内核中被引进的(epoll(4) is a new API introduced in Linux kernel 2.5.44)

epoll的优点

<1>支持一个进程打开大数目的socket描述符(FD)

select 最不能忍受的是一个进程所打开的FD是有一定限制的，由FD_SETSIZE设置，默认值是2048。对于那些需要支持的上万连接数目的IM服务器来说显然太少了。这时候你一是可以选择修改这个宏然后重新编译内核，不过资料也同时指出这样会带来网络效率的下降，二是可以选择多进程的解决方案(传统的 Apache方案)，不过虽然linux上面创建进程的代价比较小，但仍旧是不可忽视的，加上进程间数据同步远比不上线程间同步的高效，所以也不是一种完美的方案。不过 epoll则没有这个限制，它所支持的FD上限是最大可以打开文件的数目，这个数字一般远大于2048,举个例子,在1GB内存的机器上大约是10万左右，具体数目可以cat /proc/sys/fs/file-max察看,一般来说这个数目和系统内存关系很大。

<2>IO效率不随FD数目增加而线性下降

传统的select/poll另一个致命弱点就是当你拥有一个很大的socket集合，不过由于网络延时，任一时间只有部分的socket是"活跃 "的，但是select/poll每次调用都会线性扫描全部的集合，导致效率呈现线性下降。但是epoll不存在这个问题，它只会对"活跃"的 socket进行操作---这是因为在内核实现中epoll是根据每个fd上面的callback函数实现的。那么，只有"活跃"的socket才会主动的去调用 callback函数，其他idle状态socket则不会，在这点上，epoll实现了一个"伪"AIO，因为这时候推动力在os内核。在一些 benchmark中，如果所有的socket基本上都是活跃的---比如一个高速LAN环境，epoll并不比select/poll有什么效率，相反，如果过多使用epoll_ctl,效率相比还有稍微的下降。但是一旦使用idle connections模拟WAN环境,epoll的效率就远在select/poll之上了。

<3>使用mmap加速内核与用户空间的消息传递。

这点实际上涉及到epoll的具体实现了。无论是select,poll还是epoll都需要内核把FD消息通知给用户空间，如何避免不必要的内存拷贝就很重要，在这点上，epoll是通过内核于用户空间mmap同一块内存实现的。而如果你想我一样从2.5内核就关注epoll的话，一定不会忘记手工 mmap这一步的。

<4>内核微调

这一点其实不算epoll的优点了，而是整个linux平台的优点。也许你可以怀疑linux平台，但是你无法回避linux平台赋予你微调内核的能力。比如，内核TCP/IP协议栈使用内存池管理sk_buff结构，那么可以在运行时期动态调整这个内存pool(skb_head_pool)的大小--- 通过echo XXXX>/proc/sys/net/core/hot_list_length完成。再比如listen函数的第2个参数(TCP完成3次握手的数据包队列长度)，也可以根据你平台内存大小动态调整。更甚至在一个数据包面数目巨大但同时每个数据包本身大小却很小的特殊系统上尝试最新的NAPI网卡驱动架构。

epoll的使用

令人高兴的是，2.6内核的epoll比其2.5开发版本的/dev/epoll简洁了许多，所以，大部分情况下，强大的东西往往是简单的。唯一有点麻烦是epoll有2种工作方式:LT和ET。

LT(level triggered)是缺省的工作方式，并且同时支持block和no-block socket.在这种做法中，内核告诉你一个文件描述符是否就绪了，然后你可以对这个就绪的fd进行IO操作。如果你不作任何操作，内核还是会继续通知你的，所以，这种模式编程出错误可能性要小一点。传统的select/poll都是这种模型的代表．

ET (edge-triggered)是高速工作方式，只支持no-block socket。在这种模式下，当描述符从未就绪变为就绪时，内核通过epoll告诉你。然后它会假设你知道文件描述符已经就绪，并且不会再为那个文件描述符发送更多的就绪通知，直到你做了某些操作导致那个文件描述符不再为就绪状态了(比如，你在发送，接收或者接收请求，或者发送接收的数据少于一定量时导致了一个EWOULDBLOCK 错误）。但是请注意，如果一直不对这个fd作IO操作(从而导致它再次变成未就绪)，内核不会发送更多的通知(only once),不过在TCP协议中，ET模式的加速效用仍需要更多的benchmark确认。

epoll只有epoll_create,epoll_ctl,epoll_wait 3个系统调用，具体用法请参考http://www.xmailserver.org/linux-patches/nio-improve.html ，
在http://www.kegel.com/rn/也有一个完整的例子，大家一看就知道如何使用了

Leader/follower模式线程pool实现，以及和epoll的配合

易道 2007-04-18 16:36 发表评论

linux klibc 字符串比较函数是实现

易道 — Fri, 02 Jun 2006 07:07:00 GMT

int strncasecmp(const char *s1, const char *s2, size_t n)
{
const unsigned char *c1 = s1, *c2 = s2;
unsigned char ch;
int d = 0;

while ( n-- ) {
    /* toupper() expects an unsigned char (implicitly cast to int)
       as input, and returns an int, which is exactly what we want. */
    d = toupper(ch = *c1++) - toupper(*c2++);
    if ( d || !ch )
      break;
}

return d;
}

int strcasecmp(const char *s1, const char *s2)
{
const unsigned char *c1 = s1, *c2 = s2;
unsigned char ch;
int d = 0;

while ( 1 ) {
    /* toupper() expects an unsigned char (implicitly cast to int)
       as input, and returns an int, which is exactly what we want. */
    d = toupper(ch = *c1++) - toupper(*c2++);
    if ( d || !ch )
      break;
}

return d;
}

int strcmp(const char *s1, const char *s2)
{
const unsigned char *c1 = s1, *c2 = s2;
unsigned char ch;
int d = 0;

while ( 1 ) {
    d = (int)(ch = *c1++) - (int)*c2++;
    if ( d || !ch )
      break;
}

return d;
}

int strncmp(const char *s1, const char *s2, size_t n)
{
const unsigned char *c1 = s1, *c2 = s2;
unsigned char ch;
int d = 0;

while ( n-- ) {
    d = (int)(ch = *c1++) - (int)*c2++;
    if ( d || !ch )
      break;
}

return d;
}

易道 2006-06-02 15:07 发表评论

简单的智能指针-- 防止内存泄露..

易道 — Wed, 31 May 2006 09:57:00 GMT

// 一般用途
templatestruct SP_traits {
   static void Release(T* ptr)    {
       delete ptr;
   }
};

// 特殊用途
template<> struct SP_traits{
   static void Release(T* ptr)
   {
       somlist::iterator iter;
       for(iter= ptr->begin() ;iter!=ptr->end();iter++)
           delete (*iter) ;

       delete ptr;
   }
}

template
class SP//simple smart pointer
{
public:
   SP():ptr(NULL)   {
   }
   SP(T*p):ptr(p)   {
   }

   void Release()
   {
       if( ptr != NULL )
       {
           SP_traits::Release(ptr);
       }
       ptr = NULL;
   }
   T* operator=(T*p){
       Release();
       ptr = p;
       return ptr;
   }
   T** operator &() const   {
       return &ptr;
   }
   T** operator &()   {
       return &ptr;
   }
   T& operator *()   {
       return *ptr;
   }
   T& operator *()   const {
       return *ptr;
   }
   T* operator->()   {
       return ptr;
   }
   T* operator->()   const {
       return ptr;
   }
   operator T*()   {
       return ptr;
   }
   operator T*() const   {
       return ptr;
   }
   T& operator []( int i )   {
       return ptr[ i ];
   }
   T& operator []( int i )   const {
       return ptr[ i ];
   }
   bool operator == ( const T* p ){
       return ptr == p;
   }
   bool operator != ( const T* p ){
       return ptr != p;
   }
   bool operator == ( const T* p ) const {
       return ptr == p;
   }
   bool operator != ( const T* p ) const {
       return ptr != p;
   }

   ~SP()
   {
       Release();
   }
   PM_BOOL IsValid()   {
       return ptr != NULL;
   }
   void Attach( T* ptr_new )
   {
       Release();
       ptr = ptr_new;
   }
   void Detach( T* ptr_new )
   {
       ptr = NULL;
   }
   T* ptr;
};

易道 2006-05-31 17:57 发表评论

CPPunit 的简单的应用

易道 — Wed, 31 May 2006 08:42:00 GMT

/**********************************************************
*
* 测试的主函数
*
***********************************************************/

#include
#include
#include

int main(int argc, char* argv[])
{
// Get the top level suite from the registry
CPPUNIT_NS::Test *suite = CPPUNIT_NS::TestFactoryRegistry::getRegistry().makeTest();

// Adds the test to the list of test to run
CPPUNIT_NS::TextUi::TestRunner runner;
runner.addTest( suite );

// Change the default outputter to a compiler error format outputter
runner.setOutputter( new CPPUNIT_NS::CompilerOutputter( &runner.result(),
                                                       std::cerr ) );
// Run the test.
bool wasSucessful = runner.run();

// Return error code 1 if the one of test failed.
return wasSucessful ? 0 : 1;
}

/**********************************************************
*
* 测试的类的头文件
* testex.h
***********************************************************/
#include

class CTestEx : public CPPUNIT_NS::TestFixture
{
   // 开始
   CPPUNIT_TEST_SUITE( CTestEx );
   // 申明自动测试的函数
   CPPUNIT_TEST( test_f );
   // 结束
   CPPUNIT_TEST_SUITE_END();
public:
   CTestEx ();
   virtual ~CTestEx ();
   void test_f() ;
}

/**********************************************************
*
* 测试的类的实现
* testex.cpp
***********************************************************/

#include "testex.h"

CPPUNIT_TEST_SUITE_REGISTRATION( CTestEx );

void CTestEx::test_f()
{
   ....;
}

易道 2006-05-31 16:42 发表评论