Linux on ZRJ | 学习笔记

linux tcpdump

Mon, 23 Nov 2015 11:50:39 +0800

我一般用 tcpdump 有两种用法，一个是存盘，拿 wireshark 看，那么的话，就这么写

tcpdump -s 0 -i any -p udp and src 10.170.7.40 -w `date +%s`.pcap

或者实时打印到屏幕，就参考这里，http://www.askbjoernhansen.com/2007/07/12/how_to_dump_packets_with_tcpdump.html，这么写

I always forget the parameters for this and have to look them up in the man page, so enough of that:

tcpdump -nnXSs 0 ‘port 80’ “-nn” makes it not lookup hostnames in DNS and service names (in /etc/services) for respectively faster and cleaner output. “-X” makes it print each packet in hex and ascii; that’s really the useful bit for tracking headers and such “-S” print absolute rather than relative TCP sequence numbers - If I remember right this is so you can compare tcpdump outputs from multiple users doing this at once “-s 0” by default tcpdump will only capture the beginning of each packet, using 0 here will make it capture the full packets. We are debugging, right? Instead of “port 80” you can make more complicated rules like “port 80 and host 10.50.33.10”.

linux ss

Wed, 18 Nov 2015 16:27:22 +0800

ss 是一个类似 netstat 的网络连接查看工具，man page 是这么说的

ss - another utility to investigate sockets

而 netstat 的 man page 中也有说到

This program is obsolete. Replacement for netstat is ss.

常用命令有

-s 参数，打印 summary

# ss -s   
Total: 1596 (kernel 1890)
TCP:   7587 (estab 718, closed 6800, orphaned 0, synrecv 0, timewait 6779/0), ports 7376

Transport Total     IP        IPv6
*         1890      -         -        
RAW       0         0         0        
UDP       420       420       0        
TCP       787       787       0        
INET      1207      1207      0        
FRAG      0         0         0

-p 参数，打印 process name

# ss -p |head  
State      Recv-Q Send-Q      Local Address:Port          Peer Address:Port   
ESTAB      0      0           10.198.17.218:20869         10.133.33.10:9092     users:(("xxx",32492,37))
ESTAB      0      0           10.198.17.218:32516        10.231.139.30:8886     users:(("xxx",19706,17))
ESTAB      0      0           10.198.17.218:50831       10.208.146.112:31415    users:(("xx",1559,40))
ESTAB      0      0           10.198.17.218:26957       10.177.141.160:8886     users:(("xxx",1056,27))
ESTAB      0      0           10.198.17.218:56118        10.238.18.176:56328    users:(("xx",7491,19))
ESTAB      0      0           10.198.17.218:29310       10.177.130.230:6900     users:(("xxx",19715,14))
ESTAB      0      0           10.198.17.218:31249         10.209.0.153:8886     users:(("xxx",1052,29))
ESTAB      0      0           10.198.17.218:21980        10.241.90.225:50000    users:(("xxx",9211,39))
ESTAB      0      0           10.198.17.218:2452        10.177.154.166:10010    users:(("xxx",7875,24))

获取当前机器 IP

Sat, 10 Oct 2015 15:13:50 +0800

std::string GetLocalIP()         
{        
    struct ifreq req; 
    int sock_fd; 
    char szLocalIP[16]= {0};
    string strLocalIP="";

    sock_fd = socket(AF_INET,SOCK_STREAM,0);
    if(sock_fd < 0)
        return strLocalIP; 
                         
    snprintf(req.ifr_name,IFNAMSIZ,"eth1");
    if(ioctl(sock_fd,SIOCGIFADDR,(char*)&req) < 0)
    {
        close(sock_fd);
        return strLocalIP;
    }
     
    snprintf(szLocalIP,sizeof(szLocalIP)-1,inet_ntoa(((struct sockaddr_in*)(&req.ifr_addr))->sin_addr));
    close(sock_fd);
    strLocalIP=szLocalIP;
    return strLocalIP; 
}

std::string getCurrentIP() {
    const char* pSzIpAddr = "0.0.0.0";
    char szIpAddrBuffer[32] = {0};
    struct ifaddrs* pIfAddrs;
    if (getifaddrs(&pIfAddrs) == 0)
    {
        for (struct ifaddrs* pIfAddr = pIfAddrs; pIfAddr; pIfAddr = pIfAddr->ifa_next)
        {
            if (pIfAddr->ifa_addr == NULL || !(pIfAddr->ifa_flags & IFF_UP) || strncmp(pIfAddr->ifa_name, "eth1", strlen("eth1")) != 0)
            {
                continue;
            }
            if (inet_ntop(pIfAddr->ifa_addr->sa_family, &((struct sockaddr_in *)pIfAddr->ifa_addr)->sin_addr, szIpAddrBuffer, sizeof(szIpAddrBuffer)))
            {   
                pSzIpAddr = szIpAddrBuffer;
                break;                
            }
        }
        freeifaddrs(pIfAddrs);
    }
    return std::string(pSzIpAddr);
}

清除旧日志脚本

Sat, 10 Oct 2015 13:32:38 +0800

bash 的语法真是反人类啊，反人类啊啊啊

#!/bin/bash

# created: 2015-10-10 13:24:15

size=204800
echo "loop delete oldest log file until directory size < "$size" KB"

while [ 1 ]; do
    directory_size=$(du -s | cut -f1)
    if [ "$size" -gt "$directory_size" ]; then
        echo "break at directory_size "$directory_size" KB"
        break
    else
        echo "directory_size "$directory_size" KB, continue"
    fi
    oldest_log_file=$(ls -tr1 *.log | head -n 1) 
    if [ -z "$oldest_log_file" ]; then
        echo "no more log files to delete, break"
        break
    fi
    echo "deleting "$oldest_log_file"..."
    rm -rf $oldest_log_file
done;

上面没有考虑相对路径问题，crontab 中一般都是绝对路径执行的，修改如下

#!/bin/bash

# created: 2015-10-10 13:24:15

cd /data/log/unified1.0
if [ $? -ne 0 ]; then
    echo "cd dir failed"
    exit -1
fi

size=204800
echo "loop delete oldest log file until directory size < "$size" KB"

while [ 1 ]; do
    directory_size=$(du -s | cut -f1)
    if [ "$size" -gt "$directory_size" ]; then
        echo "break at directory_size "$directory_size" KB"
        break
    else
        echo "directory_size "$directory_size" KB, continue"
    fi
    oldest_log_file=$(ls -tr1 *.log | head -n 1) 
    if [ -z "$oldest_log_file" ]; then
        echo "no more log files to delete, break"
        break
    fi
    echo "deleting "$oldest_log_file"..."
    rm -rf $oldest_log_file
done;

上面的修复还是没有考虑权限，可能出现死循环，修复如下

#!/bin/bash

# created: 2015-10-10 13:24:15

cd /data/log/unified1.0
if [ $? -ne 0 ]; then
    echo "cd dir failed"
    exit -1
fi

size=204800
echo "loop delete oldest log file until directory size < "$size" KB"

while [ 1 ]; do
    directory_size=$(du -s | cut -f1)
    if [ "$size" -gt "$directory_size" ]; then
        echo "break at directory_size "$directory_size" KB"
        break
    else
        echo "directory_size "$directory_size" KB, continue"
    fi
    oldest_log_file=$(ls -tr1 *.log | head -n 1) 
    if [ -z "$oldest_log_file" ]; then
        echo "no more log files to delete, break"
        break
    fi
    echo "deleting "$oldest_log_file"..."
    rm -rf $oldest_log_file
    if [ $? -ne 0 ]; then
        echo "delete file failed"
        break
    fi
    sleep 1
done;

unix domain socket dgram

Tue, 06 Oct 2015 12:45:18 +0800

大体上参考这里，http://philherlihy.com/unix-domain-sockets-datagram/

改动之后如下

服务端

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <unistd.h>
#include <stdlib.h>

char * server_filename = "/tmp/socket-server";

int main(void)
{
    int s = socket(AF_UNIX, SOCK_DGRAM, 0);
    if (s == -1) {
        perror("socket server");
        exit(1);
    }
    
    struct sockaddr_un srv_un = {0};
    srv_un.sun_family = AF_UNIX;
    strncpy(srv_un.sun_path, server_filename, sizeof(srv_un.sun_path));

    unlink(server_filename);
    if (bind(s, (struct sockaddr *)&srv_un, sizeof(srv_un)) == -1) {
        perror("bind server");
        exit(1);
    }

    for(;;) {
        struct sockaddr_un cli_addr = {0};
        socklen_t cli_addr_len = sizeof(cli_addr);
        
        int msg;

        int recv_size = recvfrom(s, &msg, sizeof(msg), 0, (struct sockaddr*)&cli_addr, &cli_addr_len);
        if (recv_size < 0) {
            perror("recvfrom");
            break;
        }       
        printf("recv %d\n", msg);
        
        msg *= 2;
        int sendto_size = sendto(s, &msg, sizeof(msg), 0, (struct sockaddr*)&cli_addr, sizeof(cli_addr));
        if (sendto_size < 0) {
            perror("sendto");
            return -1;
        }       
        printf("send %d\n", msg); 
    }

    close(s);
    unlink(server_filename);

    return 0;
}

客户端

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <unistd.h>
#include <stdlib.h>

char * server_filename = "/tmp/socket-server";
char * client_filename = "/tmp/socket-client";

int main(void)
{
    int s = socket(AF_UNIX, SOCK_DGRAM, 0);
    if (s == -1) {
        perror("socket server");
        exit(1);
    }
    
    {
        struct sockaddr_un cli_un = { 0 };
        cli_un.sun_family = AF_UNIX;
        strncpy(cli_un.sun_path, client_filename, sizeof(cli_un.sun_path));
        
        unlink(client_filename);
        if (bind(s, (struct sockaddr *)&cli_un, sizeof(cli_un)) == -1) {
            perror("bind client");
            exit(1);
        }
    }
    
    {
        struct sockaddr_un srv_un = {0};
        srv_un.sun_family = AF_UNIX;
        strncpy(srv_un.sun_path, server_filename, sizeof(srv_un.sun_path));

        int msg = 1006;
        int sendto_size = sendto(s, &msg, sizeof(msg), 0, (struct sockaddr*)&srv_un, sizeof(srv_un));
        if (sendto_size < 0) {
            perror("sendto");
            return -1;
        }   
        printf("send %d\n", msg);
    }
    
    {
        struct sockaddr_un cli_un = { 0 };
        socklen_t cli_len = sizeof(cli_un);
        
        int msg;
        int recv_size = recvfrom(s, &msg, sizeof(msg), 0, (struct sockaddr*)&cli_un, &cli_len);
        if (recv_size < 0) {
            perror("recvfrom");
            return -1;
        }   
        printf("recv %d\n", msg); 
    }
    
    close(s);
    unlink(client_filename);
    
    return 0;
}

Linux 调用 system 函数的注意事项

Mon, 01 Jun 2015 17:46:35 +0800

来看这个代码

#include <stdio.h>
#include <stdlib.h>

int main() {
    system("sleep 5 && touch test.txt");
    FILE *fp = fopen("test.txt", "r");
    if (!fp) {
        printf("%m\n");
        return -1;
    }
    fclose(fp);
    return 0;
}

问题来了，不上机，凭理解，这个代码会有怎样的行为？

这个其实涉及到对 system 实现的理解，是 fork 完了继续跑后面代码，还是会阻塞直到命令返回，反应到这个例子上，就是瞬间跑完，报 no such file 呢，还是卡 5 秒钟，正常退出？

答案是卡 5 秒钟。原因看这里，http://my.oschina.net/renhc/blog/53580

为了更好的理解system()函数返回值，需要了解其执行过程，实际上system()函数执行了三步操作： 1.fork一个子进程； 2.在子进程中调用exec函数去执行command； 3.在父进程中调用wait去等待子进程结束。对于fork失败，system()函数返回-1。如果exec执行成功，也即command顺利执行完毕，则返回command通过exit或return返回的值。（注意，command顺利执行不代表执行成功，比如command：“rm debuglog.txt”，不管文件存不存在该command都顺利执行了）如果exec执行失败，也即command没有顺利执行，比如被信号中断，或者command命令根本不存在，system()函数返回127. 如果command为NULL，则system()函数返回非0值，一般为1.

动态链接库中的全局变量

Thu, 26 Mar 2015 14:56:46 +0800

想给自己之前的日志库，加一个染色的功能

gcc 有一个自己的特性，叫 __thread，介绍可以看这里，https://gcc.gnu.org/onlinedocs/gcc-4.2.4/gcc/Thread_002dLocal.html，是可以用来修饰一个全局变量，从而让这个全局变量在每个线程都有一份拷贝，例子如下：

#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <sys/syscall.h>

__thread int n = 0;

int ns[] = {1, 2};

void* thread_func(void *arg) {
    int tid = (int)syscall(__NR_gettid);
    printf("1, tid = %d, n = %d\n", tid, n);
    n = *((int*)arg);
    printf("2, tid = %d, n = %d\n", tid, n);
    while (1) {
        printf("3, tid = %d, n = %d\n", tid, n);
        sleep(1);
    }
}

int main() {
    for (int i = 0; i < sizeof(ns)/sizeof(ns[0]); i++) {        
        pthread_t tid;
        pthread_create(&tid, NULL, thread_func, &ns[i]);
        printf("thread %d created\n", tid);
    }
    while (1) {
        sleep(1);
    }
    return 0;
}

跑起来之后的输出是这样的

thread 1082132800 created
thread 1090525504 created
1, tid = 11508, n = 0
2, tid = 11508, n = 1
3, tid = 11508, n = 1
1, tid = 11509, n = 0
2, tid = 11509, n = 2
3, tid = 11509, n = 2
3, tid = 11508, n = 1
3, tid = 11509, n = 2
3, tid = 11508, n = 1
3, tid = 11509, n = 2
3, tid = 11508, n = 1
3, tid = 11509, n = 2

用在日志库中，成为这个样子

#include <net/if.h>
#include <arpa/inet.h>
#include "logger.h"

__thread int m_iLoggerLogTraceOn;// 是否开启染色日志

int Logger::Init(eLogLevel level, const char* pLogFileDir, const char* pLogFileBaseName, uint32_t uiLogFileRollingSize, uint32_t uiMaxCharPerLine, uint32_t uiLogBufferLines)
{
    pthread_mutex_lock(&m_stInitLock);
    if (m_bInited || level == LOG_LEVEL_OFF)
    {
        pthread_mutex_unlock(&m_stInitLock);
        return 0;
    }

然后加了一个修改的接口

void Logger::setLogTraceOn(int iTraceOn)
{
    printf("set trace switch to %d\n", iTraceOn);
    m_iLoggerLogTraceOn = iTraceOn;
    printf("after set, iLoggerLogTraceOn(%p) is %d, tid is %d\n", &m_iLoggerLogTraceOn, m_iLoggerLogTraceOn, (int)syscall(__NR_gettid));
}

在各个函数处也加了跟踪

void Logger::LogToMem(eLogLevel level, const char* format, ...)
{
    printf("trace on(%p) : %d, tid is %d\n", &m_iLoggerLogTraceOn, m_iLoggerLogTraceOn, (int)syscall(__NR_gettid));
    if (m_bInited && (level >= m_eLevel || m_iLoggerLogTraceOn))
    {
        va_list args;
        va_start(args, format);            
        char *pWritePtr = m_pLogBufferMem+((__sync_add_and_fetch(&m_uiWriteLineCount, 1) % m_uiLogBufferLines) * m_uiMaxCharPerLine);
        vsnprintf(pWritePtr+1, m_uiMaxCharPerLine-2, format, args); 
        *(pWritePtr) = 1;
        va_end(args);
    }        
}

void Logger::LogToStdout(eLogLevel level, const char* format, ...)
{    
    printf("trace on(%p) : %d, tid is %d\n", &m_iLoggerLogTraceOn, m_iLoggerLogTraceOn, (int)syscall(__NR_gettid));
    if (m_bInited && (level >= m_eLevel || m_iLoggerLogTraceOn))
    {
        va_list args;
        va_start(args, format);
        vprintf(format, args);
        va_end(args);
    }        
}

然后在业务中这么使用

if (pSession->strAppUser == "BAAEB881F489FC59")
    {
        Logger::setLogTraceOn(1);
        LOG_INFO("appuser match, turn logger trace on");
    }

然而，跑起来之后是这样的

set trace switch to 1
after set, iLoggerLogTraceOn(0x797bf0) is 1, tid is 9696
[2015-03-26 14:28:20] [INFO][            OnRequestData@          src/BusiObj.cpp,0136]  appuser match, turn logger trace on
trace on(0x43b0693c) : 0, tid is 9696
trace on(0x43b0693c) : 0, tid is 9696
trace on(0x43b0693c) : 0, tid is 9696
trace on(0x43b0693c) : 0, tid is 9696
trace on(0x43b0693c) : 0, tid is 9696

注意到一个神奇的现象，同一个变量，在同一个线程里面，指针不一样了

考虑到之前做函数耗时测试，和代码覆盖度测试的时候，遇到过由于进程关系复杂（又多进程又线程的）引起的问题，考虑是否由于这个原因引起的问题，于是写了这么一个测试

来看这个：

t2.cpp

#include <stdio.h>
#include <unistd.h>
#include <sys/syscall.h>

__thread int n = 0;

extern "C" {
    void busi(int arg) {    
        printf("1, tid = %d, n = %d\n", (int)syscall(__NR_gettid), n);
        n = arg;
        printf("2, tid = %d, n = %d\n", (int)syscall(__NR_gettid), n);
        while (1) {
            printf("3, tid = %d, n = %d\n", (int)syscall(__NR_gettid), n);
            sleep(1);
        }
    }
}

f1.cpp

#include <stdio.h>
#include <stdlib.h>
#include <dlfcn.h>
#include <pthread.h>
#include <unistd.h>

int ns[] = {1, 2};

typedef void(*busi_func_ptr_t)(int);
busi_func_ptr_t busi_func_ptr ;

void* thread_func(void *args) {
   int arg = *((int*)args); 
   printf("0, arg = %d\n", arg);
   (*busi_func_ptr)(arg);
}

int main() {    
    int fork_ret = fork();
    if (fork_ret == 0) {
        void* dll = dlopen("./t2.so", RTLD_LAZY);
        if (dll == NULL) {
            printf("%s\n", dlerror());
            abort();
        }
        busi_func_ptr = (busi_func_ptr_t)dlsym(dll, "busi");
        char *err = dlerror();
        if (err != NULL) {
            printf("%s\n", err);
            abort();
        }
        for (int i = 0; i < sizeof(ns)/sizeof(ns[0]); i++) {
            pthread_t tid;
            pthread_create(&tid, NULL, thread_func, &ns[i]);
            printf("thread %d created\n", tid);
        }
        while (1) {
            sleep(1);
        }
        dlclose(dll);
    } else {
        printf("chid proc %d\n", fork_ret);
        while (1) {
            sleep(1);
        }
    }
    return 0;
}

makefile

all:
	g++ t2.cpp -O3 -shared -o t2.so -fPIC
	g++ f1.cpp -O3 -o f1 -ldl -pthread

makefile 带 O3 是为了跟实际情况保持一致

运行输出如下

thread 1082132800 created
chid proc 12856
thread 1090525504 created
0, arg = 1
1, tid = 12857, n = 0
2, tid = 12857, n = 1
3, tid = 12857, n = 1
0, arg = 2
1, tid = 12858, n = 0
2, tid = 12858, n = 2
3, tid = 12858, n = 2
3, tid = 12857, n = 1
3, tid = 12858, n = 2
3, tid = 12857, n = 1
3, tid = 12858, n = 2

看起来是没有问题的，又考虑到，我们的日志是先编译成一个静态的 lib.a 的库，然后在编译到 lib.so 的动态库中，最后由框架加载运行的，于是试了一下这么搞

我写了一个 test.cpp

public:

	//与tcpd的接口
	char * OnRequestData(const char * p_pcResData,
		                 int p_iResDataLen,
		                 int& p_iRetDataLen,
		                 int& p_iDataBufLen, 
		                 const char *p_pcHostIP, 
		                 const char * p_pcBusiBuf,
		                 int& piProcessedDataLen, int fd)
    {
        Logger::setLogTraceOn(1);
        printf("on request123\n");
        LOG_DEBUG("on request123");
        LOG_ERR("on request123");
        Logger::setLogTraceOn(0);
        printf("on request456\n");
        LOG_DEBUG("on request456");
        LOG_ERR("on request456");
        Logger::setLogTraceOn(1);
        printf("on request789\n");
        LOG_DEBUG("on request789");
        LOG_ERR("on request789");
        Logger::setLogTraceOn(0);
        return NULL;
    }
	
	int    OnDllDataUpdate(const char * p_pcDataBuf, int p_iDataBufLen) {}
	bool   FreeMemBlock(char * p_pcMemBlock, int p_iMemBlockLen) {
        return true;
    }
	bool   InitDllWithCfgFile(const char *p_pcCfgFileName) {
        printf("%s\n", p_pcCfgFileName);
        Logger::Init(Logger::LOG_LEVEL_INFO, "./", "stdout");
        Logger::setLogTraceOn(1);
    }

然后把含有日志库的通用组件的静态库和这个 test.cpp 放在同一个目录中，编出一个动态库

g++ test.cpp libcommontool.a -shared -o lib.so -fPIC

然后用 tcpd 去加载这个动态库

这个是 Init 函数打出来的

CALL DLL INIT INTERFACE
./main.cfg
set trace switch to 1
after set, iLoggerLogTraceOn(0x51be60) is 1, tid is 15719

这个是 OnRquest 函数打出来的

set trace switch to 1
after set, iLoggerLogTraceOn(0x52f280) is 1, tid is 15721
on request123
trace on(0x4090193c) : 0, tid is 15721
trace on(0x4090193c) : 0, tid is 15721
[2015-03-26 14:49:15][ERROR][            OnRequestData@                 test.cpp,0026]  on request123
set trace switch to 0
after set, iLoggerLogTraceOn(0x52f280) is 0, tid is 15721
on request456
trace on(0x4090193c) : 0, tid is 15721
trace on(0x4090193c) : 0, tid is 15721
[2015-03-26 14:49:15][ERROR][            OnRequestData@                 test.cpp,0030]  on request456
set trace switch to 1
after set, iLoggerLogTraceOn(0x52f280) is 1, tid is 15721
on request789
trace on(0x4090193c) : 0, tid is 15721
trace on(0x4090193c) : 0, tid is 15721
[2015-03-26 14:49:15][ERROR][            OnRequestData@                 test.cpp,0034]  on request789
set trace switch to 0
after set, iLoggerLogTraceOn(0x52f280) is 0, tid is 15721

于是到此就陷入了僵局，查资料说 gcc 在编译动态链接库的时候对全局变量的处理有一些特殊，看到这里，http://blog.csdn.net/zxh821112/article/details/8969541，还有，http://blog.csdn.net/yuyin86/article/details/10239479，http://bbs.chinaunix.net/thread-1620536-1-1.html，和这里，https://www.owent.net/2014/01/cpp%E5%8F%88%E4%B8%80%E5%9D%91-%E5%8A%A8%E6%80%81%E9%93%BE%E6%8E%A5%E5%BA%93%E4%B8%AD%E7%9A%84%E5%85%A8%E5%B1%80%E5%8F%98%E9%87%8F.html，不过这些帖子在讨论，主要是集中在一个动态库被多个进程引用的时候的赋值问题，跟我们这个场景还不太一样

-—————–

2015-3-26 20:34:46 update http://lists.freebsd.org/pipermail/freebsd-hackers/2007-March/020057.html 这里有一篇，之前没发现

-——————–

2015-3-27 11:33:43 update 最后确认是编译器的问题，生产环境的编译器是 4.1.2 的老古董，换一个 gcc 4.8.2 问题就烟消云散了

分享一个多线程的日志库

Thu, 29 Jan 2015 13:12:43 +0800

思路部分参考了陈硕的 muduo，主要就是多线程写的安全性，以及一些日志分级，自动分割等常用功能，线上几十近百台机器一两年的运行没有发现什么问题

/*
 * encoding: gbk
 * created: 2013-09-05 10:33:59
 * 
 * 日志工具
 * 工具在初始化的时候从堆上分配一片内存，当作二维 char 数组来用
 * 每个写入线程在写入前对数组的一维下标原子加 1，作为本次写入
 * 的位置，写入的位置偏移 1 个字节，第 1 个字节用作标志位，写
 * 入完成后标志位置 1
 * 磁盘文件落地线程循环的检查是否有未读取的日志行，并将新的
 * 内存中日志写入磁盘
 * 
 * 使用方法：
 * #include "logger.h"
 * assert(Logger::Init() == 0);
 * LOG_INFO("sample log message %d", 123);
 */

#ifndef LOGGER_H
#define LOGGER_H

#include <errno.h>
#include <string>
#include <pthread.h>
#include <sys/syscall.h>
#include <libgen.h>
#include <stdlib.h>

#ifdef DEBUG
#define LOG_DEBUG(format, ...) do { if (Logger::m_pBeforeLogHook==NULL || (Logger::m_pBeforeLogHook!=NULL && Logger::m_pBeforeLogHook(__FILE__, __FUNCTION__)!=0)) { Logger::m_pLog(Logger::LOG_LEVEL_DEBUG, "[%s][%d][DEBUG][%25s@%25s,%04d]  " format "\n", Logger::m_szLogTimestampStr[Logger::m_iLogTimestampIndex], syscall(__NR_gettid), __FUNCTION__, __FILE__, __LINE__, ##__VA_ARGS__); } } while (0)
#define LOG_INFO(format, ...)  do { if (Logger::m_pBeforeLogHook==NULL || (Logger::m_pBeforeLogHook!=NULL && Logger::m_pBeforeLogHook(__FILE__, __FUNCTION__)!=0)) { Logger::m_pLog(Logger::LOG_LEVEL_INFO,  "[%s][%d] [INFO][%25s@%25s,%04d]  " format "\n", Logger::m_szLogTimestampStr[Logger::m_iLogTimestampIndex], syscall(__NR_gettid), __FUNCTION__, __FILE__, __LINE__, ##__VA_ARGS__); } } while (0)
#define LOG_WARN(format, ...)  do { if (Logger::m_pBeforeLogHook==NULL || (Logger::m_pBeforeLogHook!=NULL && Logger::m_pBeforeLogHook(__FILE__, __FUNCTION__)!=0)) { Logger::m_pLog(Logger::LOG_LEVEL_WARN,  "\033[1;33m" "[%s][%d] [WARN][%25s@%25s,%04d]  " format "\033[0m" "\n", Logger::m_szLogTimestampStr[Logger::m_iLogTimestampIndex], syscall(__NR_gettid), __FUNCTION__, __FILE__, __LINE__, ##__VA_ARGS__); } } while (0)
#define LOG_ERR(format, ...)   do { if (Logger::m_pBeforeLogHook==NULL || (Logger::m_pBeforeLogHook!=NULL && Logger::m_pBeforeLogHook(__FILE__, __FUNCTION__)!=0)) { Logger::m_pLog(Logger::LOG_LEVEL_ERROR, "\033[1;31m" "[%s][%d][ERROR][%25s@%25s,%04d]  " format "\033[0m" "\n", Logger::m_szLogTimestampStr[Logger::m_iLogTimestampIndex], syscall(__NR_gettid), __FUNCTION__, __FILE__, __LINE__, ##__VA_ARGS__); } } while (0)
#else
#define LOG_DEBUG(format, ...) Logger::m_pLog(Logger::LOG_LEVEL_DEBUG, "[%s][DEBUG][%25s@%25s,%04d]  " format "\n", Logger::m_szLogTimestampStr[Logger::m_iLogTimestampIndex], __FUNCTION__, __FILE__, __LINE__, ##__VA_ARGS__)
#define LOG_INFO(format, ...)  Logger::m_pLog(Logger::LOG_LEVEL_INFO,  "[%s] [INFO][%25s@%25s,%04d]  " format "\n", Logger::m_szLogTimestampStr[Logger::m_iLogTimestampIndex],  __FUNCTION__, __FILE__, __LINE__, ##__VA_ARGS__)
#define LOG_WARN(format, ...)  Logger::m_pLog(Logger::LOG_LEVEL_WARN,  "[%s] [WARN][%25s@%25s,%04d]  " format "\n", Logger::m_szLogTimestampStr[Logger::m_iLogTimestampIndex],  __FUNCTION__, __FILE__, __LINE__, ##__VA_ARGS__)
#define LOG_ERR(format, ...)   Logger::m_pLog(Logger::LOG_LEVEL_ERROR, "[%s][ERROR][%25s@%25s,%04d]  " format "\n", Logger::m_szLogTimestampStr[Logger::m_iLogTimestampIndex], __FUNCTION__, __FILE__, __LINE__, ##__VA_ARGS__)
#endif

class Logger
{
public:
    enum eLogLevel {LOG_LEVEL_DEBUG = 10, LOG_LEVEL_INFO = 20, LOG_LEVEL_WARN = 30, LOG_LEVEL_ERROR = 40, LOG_LEVEL_OFF = 50};    
    //************************************
    // Method:    Init
    // FullName:  Logger::Init
    // Access:    public static 
    // Returns:   int 0 表示初始化成功，-1 表示失败
    // Parameter: logLevel level 日志过滤等级，默认 INFO，低于该指定等级的日志将不会写入磁盘文件，也不会写入内存
    // Parameter: const char * pLogFileDir 日志文件存放的目录，默认当前目录
    // Parameter: const char * pLogFileBaseName 日志文件的文件名，不需要包括扩展名，默认当前进程名，当文件名置为 stdout 时，即时输出到屏幕
    // Parameter: uint32_t uiLogFileRollingSize 日志文件的滚动条件，文件尺寸（字节），默认 10 MB
    // Parameter: uint32_t uiMaxCharPerLine 每行最大字符数
    // Parameter: uint32_t uiLogBufferLine 缓冲区行数
    //************************************
    static int Init(eLogLevel level = LOG_LEVEL_INFO, const char* pLogFileDir = "./", const char* pLogFileBaseName = basename(getenv("_")), uint32_t uiLogFileRollingSize = 10*1024*1024, uint32_t uiMaxCharPerLine = 16384, uint32_t uiLogBufferLine = 4096);
    static void (*m_pLog)(eLogLevel level, const char* format, ...);
    static void LogToMem(eLogLevel level, const char* format, ...);
    static void LogToStdout(eLogLevel level, const char* format, ...);
    static int (*m_pBeforeLogHook)(const char* szFilename, const char* szFunctionName);
    static char m_szLogTimestampStr[2][32];
    static time_t m_stLogTimestamp;
    static int m_iLogTimestampIndex;
    // 每行最大字符数，每行的第一个字节用作标志位，为 1 表示该行写入完成可供读取，读前检查是否为 1 读取后置为 0
    static uint32_t m_uiMaxCharPerLine;
    // 最大行数，必须保证 m_uiLogBufferLines 是 2 的整数次幂
    static uint32_t m_uiLogBufferLines;
private:
    Logger();                               // 不允许实例化
    static pthread_mutex_t m_stInitLock;    // 防止多个线程同时调用 Init 函数
    static bool m_bInited;                  // 标识日志库是否初始化完毕
    static eLogLevel m_eLevel;              // 标识日志库的记录等级，大于等于这个等级的，才会写入内存，然后被写入文件
    static char *m_pLogBufferMem;           // 指向日志内存的首字节
    static uint32_t m_uiWriteLineCount;     // 日志内存写入行数累加器
};

// 磁盘文件写入线程
void* LogDumper(void *args);
struct LogDumperArgs
{
    char* pLogBufferMem;
    std::string strLogFileDir;
    std::string strLogFileName;
    uint32_t uiLogFileMaxSize; 
};

// 日志时间字符串更新线程，每 1 秒更新一次时间字符串，交替更新两个字符串数组
void* LogTimeStrGenerator(void*);

#endif

#include <string.h>
#include <string>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <libgen.h>
#include <unistd.h>
#include <stdint.h>
#include <pthread.h>
#include <time.h>
#include <stdarg.h>
#include <ifaddrs.h>
#include <net/if.h>
#include <arpa/inet.h>
#include "logger.h"

int Logger::Init(eLogLevel level, const char* pLogFileDir, const char* pLogFileBaseName, uint32_t uiLogFileRollingSize, uint32_t uiMaxCharPerLine, uint32_t uiLogBufferLines)
{
    pthread_mutex_lock(&m_stInitLock);
    if (m_bInited || level == LOG_LEVEL_OFF)
    {
        pthread_mutex_unlock(&m_stInitLock);
        return 0;
    }

    m_eLevel = level;
    m_uiMaxCharPerLine = uiMaxCharPerLine;
    if (m_uiMaxCharPerLine <= 32)
    {
        fprintf(stderr, "max char per line config error, should greater than 32, now using default value 16384\n");
        m_uiMaxCharPerLine = 16384;
    }
    m_uiLogBufferLines = uiLogBufferLines;
    if (m_uiLogBufferLines & (m_uiLogBufferLines-1) != 0)
    {
        fprintf(stderr, "log buffer line config error, must be power of 2, like 2048  4096, now using default value 4096\n");
        m_uiLogBufferLines = 4096;
    }

    memset(m_szLogTimestampStr, 0, sizeof(m_szLogTimestampStr));
    time_t stRawtime = time(NULL);
    struct tm* stTimeinfo = localtime(&stRawtime);
    strftime(Logger::m_szLogTimestampStr[0], sizeof(Logger::m_szLogTimestampStr[0])-1, "%Y-%m-%d %H:%M:%S", stTimeinfo);
    m_iLogTimestampIndex = 0;

    pthread_t tid;
    if (pthread_create(&tid, NULL, LogTimeStrGenerator, NULL) != 0)
    {
        fprintf(stderr, "create log timestamp thread failed: %s\n", strerror(errno));
        pthread_mutex_unlock(&m_stInitLock);
        return -1;
    }

    if (strcmp("stdout", pLogFileBaseName) == 0)
    {
        m_pLog = &(Logger::LogToStdout);
        m_bInited = true;
        pthread_mutex_unlock(&m_stInitLock);
        return 0;
    }
    else
    {
        m_pLog = &(Logger::LogToMem);
    }    

    int iLogBufferMemSize = m_uiMaxCharPerLine * m_uiLogBufferLines;
    m_pLogBufferMem = (char *)malloc(iLogBufferMemSize);
    if (m_pLogBufferMem == NULL)
    {
        fprintf(stderr, "alloc heap memory failed: %s\n", strerror(errno));
        pthread_mutex_unlock(&m_stInitLock);
        return -1;
    }
    m_uiWriteLineCount = 0;
    memset(m_pLogBufferMem, 0, iLogBufferMemSize);
    
    struct LogDumperArgs* pLogDumperArgs = new struct LogDumperArgs;
    pLogDumperArgs->pLogBufferMem = m_pLogBufferMem;
    pLogDumperArgs->strLogFileDir.assign(pLogFileDir);
    pLogDumperArgs->strLogFileName.assign(pLogFileBaseName);
    pLogDumperArgs->uiLogFileMaxSize = uiLogFileRollingSize;
    if (pthread_create(&tid, NULL, LogDumper, (void *)pLogDumperArgs) != 0)
    {
        fprintf(stderr, "create log dump thread failed: %s\n", strerror(errno));
        pthread_mutex_unlock(&m_stInitLock);
        return -1;
    }

    m_bInited = true;
    pthread_mutex_unlock(&m_stInitLock);
    return 0;
}

void Logger::LogToMem(eLogLevel level, const char* format, ...)
{
    if (m_bInited && level >= m_eLevel)
    {
        va_list args;
        va_start(args, format);            
        char *pWritePtr = m_pLogBufferMem+((__sync_add_and_fetch(&m_uiWriteLineCount, 1) % m_uiLogBufferLines) * m_uiMaxCharPerLine);
        vsnprintf(pWritePtr+1, m_uiMaxCharPerLine-2, format, args); 
        *(pWritePtr) = 1;
        va_end(args);
    }        
}

void Logger::LogToStdout(eLogLevel level, const char* format, ...)
{    
    if (m_bInited && level >= m_eLevel)
    {
        va_list args;
        va_start(args, format);            
        vprintf(format, args);
        va_end(args);
    }        
}

pthread_mutex_t Logger::m_stInitLock = PTHREAD_MUTEX_INITIALIZER;
bool Logger::m_bInited = false;
Logger::eLogLevel Logger::m_eLevel = Logger::LOG_LEVEL_INFO;
char* Logger::m_pLogBufferMem = NULL;
uint32_t Logger::m_uiWriteLineCount = 0;
int Logger::m_iLogTimestampIndex = 0;
char Logger::m_szLogTimestampStr[2][32] = {{0}, {0}};
time_t Logger::m_stLogTimestamp = 0;
uint32_t Logger::m_uiMaxCharPerLine = 16384;
uint32_t Logger::m_uiLogBufferLines = 4096;
void (*Logger::m_pLog)(Logger::eLogLevel level, const char* format, ...) = &(Logger::LogToMem);
int (*Logger::m_pBeforeLogHook)(const char*, const char*) = NULL;

void* LogTimeStrGenerator(void*)
{    
    while (1)
    {
        Logger::m_stLogTimestamp = time(NULL);
        struct tm* stTimeinfo = localtime(&Logger::m_stLogTimestamp);
        strftime(Logger::m_szLogTimestampStr[(Logger::m_iLogTimestampIndex+1)%2], sizeof(Logger::m_szLogTimestampStr[0])-1, "%Y-%m-%d %H:%M:%S", stTimeinfo);
        Logger::m_iLogTimestampIndex = (Logger::m_iLogTimestampIndex + 1) % 2;
        sleep(1);
    }
    return NULL;
}

void* LogDumper(void *args)
{    
    struct LogDumperArgs* pLogDumperArgs = (struct LogDumperArgs*)args;
    char* pLogBufferMem = pLogDumperArgs->pLogBufferMem;
    const std::string strLogFileDir = pLogDumperArgs->strLogFileDir;
    const std::string strLogFileName = pLogDumperArgs->strLogFileName;
    const uint32_t uiLogFileMaxSize = pLogDumperArgs->uiLogFileMaxSize;
    delete pLogDumperArgs;
    pLogDumperArgs = NULL;
    args = NULL;

    uint32_t iReadLineCount = 1;

    // 获取 IP 地址，用于文件名        
    char* pSzIpAddr = "0.0.0.0";
    char szIpAddrBuffer[32] = {0};
    struct ifaddrs* pIfAddrs;
    if (getifaddrs(&pIfAddrs) == 0)
    {
        for (struct ifaddrs* pIfAddr = pIfAddrs; pIfAddr; pIfAddr = pIfAddr->ifa_next)
        {
            if (pIfAddr->ifa_addr == NULL || !(pIfAddr->ifa_flags & IFF_UP) || strncmp(pIfAddr->ifa_name, "eth1", strlen("eth1")) != 0)
            {
                continue;
            }
            if (inet_ntop(pIfAddr->ifa_addr->sa_family, &((struct sockaddr_in *)pIfAddr->ifa_addr)->sin_addr, szIpAddrBuffer, sizeof(szIpAddrBuffer)))
            {   
                pSzIpAddr = szIpAddrBuffer;
                break;                
            }
        }
        freeifaddrs(pIfAddrs);
    }
    // 获取进程 ID，用于文件名
    pid_t pid = getpid();

    // 检查目录是否存在，不存在则自动创建
    char szMkdirpCmd[512] = {0};
    snprintf(szMkdirpCmd, sizeof(szMkdirpCmd), "mkdir -p %s", strLogFileDir.c_str());
    system(szMkdirpCmd);

    // 开始写入文件
    while (1)
    {
        // 获取当前时间，用于文件名
        time_t stRawtime = time(NULL);
        struct tm* stTimeinfo = localtime(&stRawtime);
        char pTimeBuffer[80] = {0}, pLogFileFullName[512] = {0}, pLogFileLinkName[512] = {0};
        strftime(pTimeBuffer, sizeof(pTimeBuffer)-1, "%Y%m%d%H%M%S", stTimeinfo);
        snprintf(pLogFileFullName, sizeof(pLogFileFullName)-1, "%s/%s_%s_%s_%d.log", strLogFileDir.c_str(), strLogFileName.c_str(), pTimeBuffer, pSzIpAddr, pid);
        snprintf(pLogFileLinkName, sizeof(pLogFileLinkName)-1, "%s.log", strLogFileName.c_str());
        FILE* fp = fopen(pLogFileFullName, "a+");
        if (fp == NULL)
        {
            fprintf(stderr, "open log file %s failed: %s\n", pLogFileFullName, strerror(errno));
            return NULL;
        }
        // 建立软链接
        unlink(pLogFileLinkName);
        symlink(pLogFileFullName, pLogFileLinkName);

        uint32_t uiWriteByteCount = 0;
        time_t stLastFlushTimestamp = 0;
        while (1)
        {        
            char* pReadPtr = pLogBufferMem+((iReadLineCount % Logger::m_uiLogBufferLines) * Logger::m_uiMaxCharPerLine);
            if (*pReadPtr == 1)
            {
                uiWriteByteCount += fprintf(fp, "%s", pReadPtr + 1);
                *pReadPtr = 0;
                iReadLineCount++;
                if (uiWriteByteCount > uiLogFileMaxSize)
                {
                    break;
                }
            } 
            else
            {
                if (Logger::m_stLogTimestamp - stLastFlushTimestamp >= 3)
                {
                    stLastFlushTimestamp = Logger::m_stLogTimestamp;
                    fflush(fp);
                }
                usleep(5000);
            }    
        }        

        fclose(fp);
    }
      
    return NULL;
}

历史评论

动态链接库中的全局变量 | ZRJ (2015-03-26 14:56:49):

[…] 想给自己之前的日志库，加一个染色的功能 […]

Linux bash explode string

Tue, 28 Oct 2014 11:18:36 +0800

想要对一个很长的行根据分隔符断开，搜了一下，这次万能的 stackoverflow 居然没有合适的答案，于是只能自己搞，想了想，其实很简单，这么写就可以了

head part-00079 -n 1 | sed "s/\t/\r\n/g"

其实就是 sed，这个思路可以自由发挥的空间很大，想实现什么效果都简单

Linux 交换分区耗尽

Fri, 10 Oct 2014 10:20:29 +0800

今天在跑自己的业务进程的时候发现很卡，看了一下这个 free 命令的输出

$ free -m
             total       used       free     shared    buffers     cached
Mem:          7972        727       7244          0          0        420
-/+ buffers/cache:        306       7666
Swap:         1913       1913          0

可以看到，物理内存几乎是空闲的，但是，交换分区耗尽了。按照我们的理解，Linux 对于内存的使用策略，应该是优先使用物理内存，直到物理内存不够用的时候，才开始动用交换分区。那么，很自然的，我们就要提一个问题了，（别怕，不是问挖掘机），为什么会出现上述的这种情况。细分来说主要有以下几个问题：

什么情况才会使得 Linux 系统出现这种物理内存没用完就去用交换分区的行为
在这个情景下，交换分区中到底是什么鸟东西
出现这种情况，怎么释放交换分区，怎么让系统恢复正常

按照国际惯例，首先放狗搜，在这里，http://tech.foolpig.com/2012/12/14/linux-swap-process/?，可以看到有人写了一个脚本，用于统计每个进程对于交换分区的占用。

#!/bin/bash

##############################################################################
# 脚本功能 ： 列出正在占用swap的进程。
###############################################################################

echo -e "PID\t\tSwap\t\tProc_Name"

# 拿出/proc目录下所有以数字为名的目录（进程名是数字才是进程，其他如sys,net等存放的是其他信息）
for pid in `ls -l /proc | grep ^d | awk '{ print $9 }'| grep -v [^0-9]`
do
    # 让进程释放swap的方法只有一个：就是重启该进程。或者等其自动释放。放
    # 如果进程会自动释放，那么我们就不会写脚本来找他了，找他都是因为他没有自动释放。
    # 所以我们要列出占用swap并需要重启的进程，但是init这个进程是系统里所有进程的祖先进程
    # 重启init进程意味着重启系统，这是万万不可以的，所以就不必检测他了，以免对系统造成影响。
    if [ $pid -eq 1 ];then continue;fi
    grep -q "Swap" /proc/$pid/smaps 2>/dev/null
    if [ $? -eq 0 ];then
        swap=$(grep Swap /proc/$pid/smaps \
            | gawk '{ sum+=$2;} END{ print sum }')
        proc_name=$(ps aux | grep -w "$pid" | grep -v grep \
            | awk '{ for(i=11;i<=NF;i++){ printf("%s ",$i); }}')
        if [ $swap -gt 0 ];then
            echo -e "${pid}\t${swap}\t${proc_name}"
        fi
    fi
done | sort -k2 -n | awk -F'\t' '{
    pid[NR]=$1;
    size[NR]=$2;
    name[NR]=$3;
}
END{
    for(id=1;id<=length(pid);id++)
    {
        if(size[id]<1024)
            printf("%-10s\t%15sKB\t%s\n",pid[id],size[id],name[id]);
        else if(size[id]<1048576)
            printf("%-10s\t%15.2fMB\t%s\n",pid[id],size[id]/1024,name[id]);
        else
            printf("%-10s\t%15.2fGB\t%s\n",pid[id],size[id]/1048576,name[id]);
    }
}'

样例输出如下：

[root@slide Downloads]# ./check_swap_use2.sh
PID		             Swap      Proc_Name
4165      	             32KB	klogd -x
4179      	             56KB	irqbalance
4162      	             64KB	syslogd -m 0
4221      	             64KB	/sbin/mingetty tty2
4222      	             64KB	/sbin/mingetty tty3
4223      	             64KB	/sbin/mingetty tty4
4224      	             68KB	/sbin/mingetty tty5
4225      	             68KB	/sbin/mingetty tty6
14145     	            124KB	rsync
14166     	            124KB	rsync
14139     	            128KB	rsync
31109     	            244KB	/bin/sh /usr/local/mysql-5.5.8/bin/mysqld_safe
18417     	            280KB	/usr/local/nagios-3.2.3/bin/nrpe
1478      	            376KB	/sbin/udevd -d
27204     	            400KB	/usr/bin/perl
4197      	            452KB	/usr/sbin/sshd
4210      	            508KB	crond
25954     	            832KB	/usr/bin/redis-server
25927     	            988KB	/usr/bin/redis-server
25964     	           1.01MB	/usr/bin/redis-server
24197     	           1.37MB	/usr/bin/redis-server
25860     	           1.55MB	/usr/bin/redis-server
26746     	           2.02MB	/usr/local/net-snmp-5.6.1/sbin/snmpd
17008     	           2.09MB	/usr/bin/redis-server
4897      	           4.23MB	/usr/local/redis-2.2.4/bin/redis-server
25677     	          11.74MB	/usr/bin/redis-server
19694     	          21.12MB	/usr/local/redis-2.4.17/bin/redis-server
25873     	          22.85MB	/usr/bin/redis-server
14631     	          23.45MB	/usr/bin/redis-server
31361     	          47.79MB	/usr/local/mysql-5.5.8/bin/mysqld
26043     	         110.27MB	/usr/bin/redis-server
25808     	         127.93MB	/usr/bin/redis-server

自行写脚本固然可以，但是有没有简便的办法呢，在这里，http://stackoverflow.com/questions/479953/how-to-find-out-which-processes-are-swapping-in-linux?，有另外一位大哥给出了一个依赖系统自带的 top 的方法，在 top 命令中，按 f，就是 field 的意思，调出列选项，把 swap 列显示出来，然后按 O，大写的，应该是 order 的意思，选择按照 swap 列进行排序，可以看到下面的结果

PID USER      PR  NI  VIRT  SHR  RES S %CPU %MEM    TIME+  SWAP COMMAND
19899 root      22   0 4710m  288 227m S    0  2.9   0:02.72 4.4g java
 3633 mysql     17   0  752m  116 1484 S    0  0.0   0:00.50 750m mysqld

可以看到就是 java 这个大家伙占用了 4G 的交换分区空间，（但是，注意，之前看到的，交换分区一共才 2G 左右啊），其次是 mysql 的守护进程，占用了 750M，（这里又一个注意，这么一来，各个进程的交换分区占用加起来，远远比交换分区的总量大）。

可惜的是，这个方法虽然简单，但是不靠谱。在这个 stackoverflow 的问答下面，评论里有人说了：

Your accepted answer is wrong. Consider changing it to lolotux’s answer, which is actually correct.

为什么不靠谱呢，原因如下：

It is not possible to get the exact size of used swap space of a process. Top fakes this information by making SWAP = VIRT - RES, but that is not a good metric, because other stuff such as video memory counts on VIRT as well (for example: top says my X process is using 81M of swap, but it also reports my system as a whole is using only 2M of swap. Therefore, I will not add a similar Swap column to htop because I don’t know a reliable way to get this information (actually, I don’t think it’s possible to get an exact number, because of shared pages).

下面有一个更高票的答案，还是走的自行写脚本的方法：

#!/bin/bash
# Get current swap usage for all running processes
# Erik Ljungstrom 27/05/2011
# Modified by Mikko Rantalainen 2012-08-09
# Pipe the output to "sort -nk3" to get sorted output
# Modified by Marc Methot 2014-09-18
# removed the need for sudo

SUM=0
OVERALL=0
for DIR in `find /proc/ -maxdepth 1 -type d -regex "^/proc/[0-9]+"`
do
    PID=`echo $DIR | cut -d / -f 3`
    PROGNAME=`ps -p $PID -o comm --no-headers`
    for SWAP in `grep VmSwap $DIR/status 2>/dev/null | awk '{ print $2 }'`
    do
        let SUM=$SUM+$SWAP
    done
    if (( $SUM > 0 )); then
        echo "PID=$PID swapped $SUM KB ($PROGNAME)"
    fi
    let OVERALL=$OVERALL+$SUM
    SUM=0
done
echo "Overall swap used: $OVERALL KB"

上述的两个脚本我都跑了一下，结果如下（切换到 root 权限）：

# ./swap_stat_1.sh
PID		Swap		Proc_Name
# ./swap_stat_2.sh
Overall swap used: 0 KB

汗，这是几个意思啊。

没办法了，只能挽起袖子，看看这些个脚本到底是怎么统计的，然后手工执行一遍，看看是哪个环节出的岔子。

前面那个脚本是通过 proc 里面的 smaps 文件来查找 Swap 字眼，进行统计的，但是我手工跑了一下，java 的那个进程里面，根本就没有 Swap 这个字眼。

后面的那个脚本是通过 proc 里面的 status 文件来统计的，查找的是?VmSwap 字符串，可惜的是，在文件里面这个字符串也是没有的。

所以他们都不能统计出每个进程的交换分区用了多少。

那为什么这些文件里面都没有本来用于表示交换分区占用大小的字段呢？

正在感觉黔驴技穷的时候，无意中看到之前为了查 java 的进程号的时候敲的命令

# ps -ef|grep java
root     19899 19897  0 Sep23 pts/2    00:00:02 /usr/java/jdk1.7.0_02/bin/java -server -Xms4g -Xmx4g -Xmn2g -XX:PermSize=128m -XX:MaxPermSize=320m -XX:+UseConcMarkSweepGC -XX:+UseCMSCompactAtFullCollection -XX:CMSInitiatingOccupancyFraction=70 -XX:+CMSParallelRemarkEnabled -XX:SoftRefLRUPolicyMSPerMB=0 -XX:+CMSClassUnloadingEnabled -XX:SurvivorRatio=8 -XX:+DisableExplicitGC -verbose:gc -Xloggc:/root/rmq_srv_gc.log -XX:+PrintGCDetails -XX:-OmitStackTraceInFastThrow -Djava.ext.dirs=/usr/local/rocketmq/bin/../lib -cp .:/usr/local/rocketmq/bin/../conf:.:/usr/java/jdk1.7.0_02/lib/tools.jar com.alibaba.rocketmq.namesrv.NamesrvStartup
root     20186  1906  0 17:04 pts/1    00:00:00 grep java

把 java 进程的命令行启动参数纵列来看

/usr/java/jdk1.7.0_02/bin/java
-server
-Xms4g
-Xmx4g
-Xmn2g
-XX:PermSize=128m
-XX:MaxPermSize=320m
-XX:+UseConcMarkSweepGC
-XX:+UseCMSCompactAtFullCollection
-XX:CMSInitiatingOccupancyFraction=70
-XX:+CMSParallelRemarkEnabled
-XX:SoftRefLRUPolicyMSPerMB=0
-XX:+CMSClassUnloadingEnabled
-XX:SurvivorRatio=8
-XX:+DisableExplicitGC
-verbose:gc
-Xloggc:/root/rmq_srv_gc.log
-XX:+PrintGCDetails
-XX:-OmitStackTraceInFastThrow
-Djava.ext.dirs=/usr/local/rocketmq/bin/../lib
-cp .:/usr/local/rocketmq/bin/../conf:.:/usr/java/jdk1.7.0_02/lib/tools.jar com.alibaba.rocketmq.namesrv.NamesrvStartup

很明显可以注意到上面有一个 -Xms4g 和 -Xmx4g，这两个我印象中是用于指定虚拟机的内存大小的。在这里，http://www.cnblogs.com/redcreen/archive/2011/05/04/2037057.html?，可以看到解释：

参数名称 含义 默认值

-Xms 初始堆大小物理内存的1/64(<1GB) 默认(MinHeapFreeRatio参数可以调整)空余堆内存小于40%时，JVM就会增大堆直到-Xmx的最大限制.

-Xmx 最大堆大小物理内存的1/4(<1GB) 默认(MaxHeapFreeRatio参数可以调整)空余堆内存大于70%时，JVM会减少堆直到 -Xms的最小限制

-Xmn 年轻代大小(1.4or lator) 注意：此处的大小是（eden+ 2 survivor space).与jmap -heap中显示的New gen是不同的。整个堆大小=年轻代大小 + 年老代大小 + 持久代大小. 增大年轻代后,将会减小年老代大小.此值对系统性能影响较大,Sun官方推荐配置为整个堆的3/8

参数名称	含义	默认值
-Xms	初始堆大小	物理内存的1/64(<1GB)	默认(MinHeapFreeRatio参数可以调整)空余堆内存小于40%时，JVM就会增大堆直到-Xmx的最大限制.
-Xmx	最大堆大小	物理内存的1/4(<1GB)	默认(MaxHeapFreeRatio参数可以调整)空余堆内存大于70%时，JVM会减少堆直到 -Xms的最小限制
-Xmn	年轻代大小(1.4or lator)		注意：此处的大小是（eden+ 2 survivor space).与jmap -heap中显示的New gen是不同的。整个堆大小=年轻代大小 + 年老代大小 + 持久代大小. 增大年轻代后,将会减小年老代大小.此值对系统性能影响较大,Sun官方推荐配置为整个堆的3/8

可以看到由于启动的时候把初始堆大小和最大堆大小都配置为 4G，所以导致 java 进程后面的问题。

到了这一步，可以初步提出一个假设的场景：在开始的时候，java 进程启动，由于初始内存和最大内存都配的太大，所以 java 进程消耗了大量的物理内存，然而，java 进程启动后，并不繁忙（通过 CPU 占用推断），所以对这些索要到手的内存也没有好好利用，这本来也相安无事。然而，后来又启动了一个进程（也就是我的业务），这个业务进程也不是吃素的，他也需要很多内存，正好 java 进程在放羊，于是 java 进程就被 Linux 系统从物理内存中驱逐出去，赶到交换分区了，然后，我的业务进程跑完之后，被我杀掉，于是我的业务进程占用的物理内存也释放出来了，这个时候如果 java 进程活跃的话，他应该是可以复辟的，可惜他太消极怠工了，于是就一直被打在冷宫，呆在交换分区一直没能出来见天日。

啊，听上去真是一个圆满的假设，但是，怎么证明我的假设呢？想了想，可以这么来：

首先，杀掉 java 进程，观察交换分区的占用是否下降，应该可以证明是否真的是 java 进程在占用交换分区。
其次，如果第一步成功了，那么我们用相同的参数重启 java 进程，应该可以看到 java 进程在占用物理内存，由于物理内存有 8G，所以应该足够 java 进程这个败家子坐吃不至于山空的。这个时候应该观察到物理内存的占用上升了，交换分区的占用还是维持在低水平。
然后，启动我的业务进程，由于我的业务进程也向系统索要内存，所以系统大量 IO，把 java 换到交换分区，这里就是我感觉到卡的原因了。这一步完成之后应该观察到我的业务进程占用了大量的物理内存，同时交换分区也被占用了。
最后，把我的进程杀掉，这个时候应该可以看到物理内存的占用下降，但是交换分区的占用依然维持高位，也就是这个文章最开始的时候提出的场景了。

秉承着打 LOL 输赢看淡想好就干的精神，立刻准备动手，动手前再次确认系统的目前状态，通过 top 命令。（这里其实有点不自洽，因为前面说了 top 的交换分区是不准的，但是没办法啊，精准的那个方法死火了，只能先这样了）

Mem:   8163812k total,   752632k used,  7411180k free,      352k buffers
Swap:  1959920k total,  1959920k used,        0k free,   425144k cached

  PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  SWAP COMMAND
19899 root      22   0 4710m 234m  264 S    0  2.9   0:03.44 4.4g java

杀掉 java 进程

# kill -9 19899

看一下 free

# free -m
             total       used       free     shared    buffers     cached
Mem:          7972        512       7459          0          0        427
-/+ buffers/cache:         85       7887
Swap:         1913       1546        367

空闲的只有 367MB，占用的还有 1.5G 左右，回去看看 top

PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  SWAP COMMAND
 3633 mysql     17   0  752m 1484  116 S    0  0.0   0:00.83 750m mysqld
22046 adenzhan  17   0  583m  212   36 S    0  0.0   0:00.40 583m QQActSrv
 4680 root      15   0 32752  284   88 S    0  0.0   0:01.05  31m redis-server
 2627 root      19   0 31208   20   16 S    0  0.0   0:00.02  30m sshd
 1765 root      16   0 29884 1684  784 S    0  0.0   0:01.91  27m agent
 1905 root      17   0 25436  420   16 S    0  0.0   0:00.00  24m su
28422 root      19   0 24072   88    8 S    0  0.0   0:00.00  23m smbd
28421 root      16   0 24072  196   12 S    0  0.0   0:00.01  23m smbd
 1878 root      16   0 15556  468  184 S    0  0.0   0:01.26  14m hald
 1820 messageb  15   0 14192  120   12 S    0  0.0   0:00.09  13m dbus-daemon
21756 root      16   0 13288   20   16 S    0  0.0   0:00.06  12m bash
 3663 root      15   0 13288   32   16 S    0  0.0   0:00.26  12m bash
 3670 root      17   0 13296  124   64 S    0  0.0   0:00.09  12m bash
 3673 root      16   0 13284  660   16 S    0  0.0   0:00.13  12m bash
 3672 root      17   0 13292  704   16 S    0  0.0   0:00.06  12m bash
 4115 at        16   0 12984  560  192 S    0  0.0   0:02.04  12m atd
29432 adenzhan  15   0 13828 1440   16 S    0  0.0   0:00.07  12m bash
23065 adenzhan  15   0 13828 1576   24 S    0  0.0   0:00.25  11m bash
 2637 root      17   0 12340  188  124 S    0  0.0   0:02.09  11m cron
22910 root      17   0 13116 1156   24 S    0  0.0   0:00.12  11m bash
 1906 root      16   0 13292 1896  596 S    0  0.0   0:00.13  11m bash
 2658 root      25   0 11384   16   12 S    0  0.0   0:00.04  11m mysqld_safe
22045 adenzhan  16   0 10488  192   28 S    0  0.0   0:00.03  10m QQActSrv
 2338 root      15   0 10360  340  196 S    0  0.0   0:03.29 9.8m syslog-ng

前面两个占了大头，后面的虾兵蟹将，加起来差不多 1676MB，也差不多能对上。

然后就是重启 java 进程了。

# /usr/java/jdk1.7.0_02/bin/java -server -Xms4g -Xmx4g -Xmn2g -XX:PermSize=128m -XX:MaxPermSize=320m -XX:+UseConcMarkSweepGC -XX:+UseCMSCompactAtFullCollection -XX:CMSInitiatingOccupancyFraction=70 -XX:+CMSParallelRemarkEnabled -XX:SoftRefLRUPolicyMSPerMB=0 -XX:+CMSClassUnloadingEnabled -XX:SurvivorRatio=8 -XX:+DisableExplicitGC -verbose:gc -Xloggc:/root/rmq_srv_gc.log -XX:+PrintGCDetails -XX:-OmitStackTraceInFastThrow -Djava.ext.dirs=/usr/local/rocketmq/bin/../lib -cp .:/usr/local/rocketmq/bin/../conf:.:/usr/java/jdk1.7.0_02/lib/tools.jar com.alibaba.rocketmq.namesrv.NamesrvStartup
The Name Server boot success.

再看一下内存

Mem:   8163812k total,   629772k used,  7534040k free,     2524k buffers
Swap:  1959920k total,  1583124k used,   376796k free,   484348k cached

  PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  SWAP COMMAND
31368 root      18   0 4657m  62m  10m S    0  0.8   0:00.83 4.5g java

悲剧，完全不按照套路出牌。java 进程已经重新启动了，但是物理内存还是空空如也，交换分区也没有被占用。

此路不通，看来之前的问题还是绕不过去，那就是在交换分区里面的，到底是什么在占用呢。

为了验证那些空闲的物理内存是不是真的可以用，我写了一个小代码测试：

#include <stdio.h>
#include <time.h>
#include <string>
#include <map>

int main() {
    int i = 0;
    while (1) {
        int n = 100 * 1024 * 1024;
        char* p = (char*)malloc(n);
        for (int j = 0; j < n; j++) {
            p[j] = 0;
        }
        printf("%d\n", i);
        i++;
        sleep(1);
    }
    return 0;
}

跑起来之后用 vmstat 进行持续的观察

procs -----------memory---------- ---swap-- -----io---- -system-- -----cpu------
 r  b   swpd   free   buff  cache   si   so    bi    bo   in   cs us sy id wa st
 0  0 1958772 7174560 222488 185668    0    0     0     0  264  270  6  0 93  0  0
 1  0 1958772 7095324 222488 185668    0    0     0     0  263  266  6  0 94  0  0
 0  0 1958772 7072012 222488 185668    0    0     0     0  258  254  2  0 98  0  0
 0  0 1958772 6969340 222488 185668    0    0     0     0  259  266  7  0 92  0  0
 1  0 1958772 6924700 222488 185668    0    0     0     0  261  259  3  0 97  0  0
 0  0 1958772 6866792 222496 185660    0    0     0    16  271  269  4  0 95  0  0
 0  0 1958772 6764740 222496 185660    0    0     0     0  260  261  7  0 92  0  0
 1  0 1958772 6754572 222496 185660    0    0     0     0  260  257  1  0 99  0  0
 0  0 1958772 6662068 222496 185660    0    0     0     0  262  262  6  0 93  0  0
 1  0 1958772 6584196 222496 185660    0    0     0     0  263  266  6  0 94  0  0
 0  0 1958772 6559520 222496 185660    0    0     0     0  266  262  1  0 98  0  0
 0  0 1958772 6456848 222496 185660    0    0     0     0  262  264  7  0 93  0  0
 1  0 1958772 6413572 222496 185660    0    0     0     0  255  257  3  0 97  0  0
 0  0 1958772 6354424 222496 185660    0    0     0     0  260  261  4  0 96  0  0
 0  1 1959920 6251876 222496 184512    0    0     0     0  264  267  7  0 90  2  0
 1  1 1959920 6245952 222496 182456    0    0     0     0  265  286  1  0 87 13  0
 0  1 1959920 6281508 134508 140916    0    0     0     0  257  276  7  1 80 12  0

可以看到物理内存是确实在下降的，这说明那片内存是真的可以使用。

在继续搜索的过程中，看到这里，http://www.cnblogs.com/kumulinux/archive/2012/11/29/2808681.html?，提到

内存不足无疑会SWAP，但有些时候，即便看上去内存很充裕，还可能会SWAP，这种现象被称为SWAP Insanity

下面讲了一些 MySQL 的案例，例如：

NUMA的诅咒

NUMA在MySQL社区有很多讨论，这里不多说了，直击NUMA和SWAP的恩怨纠葛。

大概了解一下NUMA最核心的numactl命令：

shell> numactl –hardware available: 2 nodes (0-1) node 0 size: 16131 MB node 0 free: 100 MB node 1 size: 16160 MB node 1 free: 10 MB node distances: node 0 1 0: 10 20 1: 20 10 可以看到系统有两个节点（其实就是两个物理CPU），它们各自分了16G内存，其中零号节点还剩100M内存，一号节点还剩10M内存。设想启动了一个需要11M内存的进程，系统把它分给了一号节点来执行，此时虽然系统总体的可用内存大于该进程需要的内存，但因为一号节点本身剩余的可用内存不足，所以仍然可能会触发SWAP行为。

需要说明的一点事，numactl命令中看到的各节点剩余内存中时不包括Cache内存的，如果需要知道，我们可以利用drop_caches参数先释放它：

shell> sysctl vm.drop_caches=1 注：这步操作可能会引起系统负载的震荡。

另：如何确定一个进程的节点及内存分配情况？网络上有现成的脚本。

如果要规避NUMA对SWAP的影响，最简单的方法就是在启动进程的时候禁用它：

shell> numactl –interleave=all … 此外，内核参数zone_reclaim_mode通常也很重要，当某个节点可用内存不足时，如果为0的话，那么系统会倾向于从远程节点分配内存；如果为1的话，那么系统会倾向于从本地节点回收Cache内存。多数时候，Cache对性能很重要，所以0是一个更好的选择。

病急乱投医，记得之前在 top 排名里面也有看到 MySQL，这不禁让我们开始疑神疑鬼起来。

依葫芦画瓢，我们来看一下：

# numactl --hardware
libnuma: Warning: /sys not mounted or no numa system. Assuming one node: No such file or directory
available: 1 nodes (0-0)
node 0 size: <not available>
node 0 free: <not available>
libnuma: Warning: Cannot parse distance information in sysfs: No such file or directory
No distance information available.

这是要吐血的节奏啊。不过，虽然输出里面写着各种 not available，但是，我们起码可以知道我们是 1 node，这样的话，应该就跟 NUMA 没什么太大关系了，因为 NUMA 是一个多核多 CPU 架构上的问题。

看到这儿，各位看官可能要问了，咋么不直接把 MySQL 也杀掉啊，宁可错杀一千不要放过一个，说不定杀掉就好了啊，唉，一把辛酸泪，这个是个共用的开发机啊，其实那个 java 进程和这个 MySQL 进程都不是我的，之前我杀 java 进程的时候也是抱着一种做贼一样的心态偷偷摸摸杀了赶紧重启的，不过，事到如今没办法了，一不做二不休，把 MySQL 也干掉，我们再看看。

在杀掉 MySQL 之前，再次确认现在的现状，我再次把我的业务进程拉起，然后通过 vmstat 来观察机器运行状态。

分两段来看，这个是在编译期间的统计过程

2  0 1013384 6359004  88980 1306032    0    0   116     0  274  351 23  1 75  0  0
 2  1 1013384 6685740  12668 1124360    0    0  1464    32  326  316 24  2 68  7  0
 2  1 1013384 6774932  12696 1124616    0    0   476     0  307  340 23  1 63 13  0
 1  3 1269272 6905620  12124 821184    0    0    92 11668  468  569 21  4 61 14  0
 2  1 1348368 6863208  12208 742004    0    0  1728     0  362  424 16  2 64 18  0
 0  2 1600160 7064960  12296 478072    0 106720   212 106848  475  479  7  5 78 10  0
 0  3 1653436 7122228  12356 424544    0 62032   780 62048  457  454  0  2 79 19  0
 0  4 1686524 7159148  12364 390036    0 38312  1152 38348  434  455  0  1 76 22  0
 0  5 1697276 7162764  12372 380728    0 17100  2852 19584  382  408  0  1 80 18  0
 0  5 1736972 7206564  12308 341244    0 69936   564 70636  437  349  0  1 82 16  0
 0  6 1752928 7240816  12372 322480    0 22624  1192 22624  401  421  0  1 67 32  0
 0  7 1755268 7239972  12488 326592    0 3976  6204  3980  670 1423  2  1 57 40  0
 0  8 1758032 7286824  12368 325028    0 4048  1108  4088  474 1374  1  2 61 37  0
procs -----------memory---------- ---swap-- -----io---- -system-- -----cpu------
 r  b   swpd   free   buff  cache   si   so    bi    bo   in   cs us sy id wa st
 2  5 1760724 7283756  12164 325752    0 5076  2520  5076  449 1305  1  1 61 37  0
 0  3 1766428 7315792  12188 326272    0 10028  1632 10088  553 1290  1  1 75 23  0
 0  3 1773476 7332700  12244 319736    0 15408    52 15480  592  380  0  1 80 19  0
 0  2 1783144 7360904   4196 300976    0 21268    60 21272  538  389  0  1 88 11  0
 0  3 1790256 7381244   4264 294616    0 14516    68 14592  495  412  0  1 82 18  0
 0  4 1796104 7393724   4332 287880    0 10960    68 18608  464  421  0  1 75 24  0
 0  4 1802432 7406564   4412 281944    0 11920    64 12140  495  406  0  1 81 18  0
 0  2 1816432 7421220   4444 267332    0 19328    28 19332  511  355  0  0 81 19  0
 0  2 1843756 7457948   2416 232680    0 34324    80 34324  541  452  0  1 87 11  0
 0  2 1844524 7477880   2484 231908    0 1744    68  1744  444  399  0  0 87 12  0
 0  3 1868084 7503132   2568 208124    0 31556    84 31648  706  441  0  2 83 15  0
 0  2 1878660 7513636   2628 197612    0 11148    60 11148  487  397  0  1 81 18  0
 0  4 1887364 7526612   2692 189704    0 9716  1080  9716  500  464  0  1 83 16  0
 0  2 1892252 7527292   2740 190488    0 11036  2096 11036  497  762  2  1 66 31  0
 0  3 1905636 7542664   2760 176580    0 15116   104 15148  529  539  0  1 85 14  0
 0  4 1911460 7545984   2836 170656    0 6472   372  9288  507  507  0  1 80 19  0
 0  5 1919496 7556060   2896 162600    0 8696   128  8944  583  447  0  1 77 22  0
 0  4 1940944 7574196   3028 140100    0 26088  1268 26088  830 1343  0  2 77 20  0
 0  4 1940944 7562912   3096 143648    0 6492  3492  6492  592  874  3  1 80 16  0
 0  2 1945880 7542348   3156 138988    0 5752   484  5752  488  617  1  1 80 18  0
 0  5 1958360 7560328   3200 124944    0 18068   224 18092  563  609  0  1 73 26  0
 0  4 1958852 7571568   3208 120276    0 5344    44  5348  478  432  0  0 66 33  0
 0  3 1959920 7582708   3216 119404    0 20468   264 20568  628  655  0  1 69 29  0
 0  4 1959920 7593388   3244 119116    0 12704    88 12780  482  466  0  1 68 31  0
 1  2 1959920 7551580   3312 119048    0    0  1328     0  425 1336  2  1 71 26  0
 3  0 1959920 7352008   3364 120024    0    0  1492     0  437  754 26  3 64  7  0
 3  0 1959920 7090496   3380 118980    0    0    24     0  262  352 36  1 63  0  0
 3  0 1959920 7162064   3412 122032    0    0   488     0  291  416 33  2 63  2  0

block in/out 和用户态的 CPU 占用都很好理解，编译器需要从磁盘把源文件，或者中间过程的目标文件读进来，分析生成后，把结果文件写回磁盘，所以有产生一定的磁盘 IO 伴随着用户态的 CPU 占用是很合情合理的。

但是在这个过程中，不正常的是发生了大量的 swap out，大量的数据从内存换出到交换分区，而与此同时，物理内存的空闲其实很大，这一点就是症结所在了。

下面再来看业务进程跑起来之后的统计。

1  0 1959920 7310056   5308 361716    0    0     0     0  256  271 12  0 88  0  0
 1  0 1959920 7250908   5308 361716    0    0     0     0  263  278 12  0 87  0  0
 1  1 1959920 7238144   5320 361704    0    0     0 26556  549  284 12  1 77 10  0
 0  1 1959920 7397820   5624 370652    0    0   604     0  336 1094  8  2 86  4  0
 1  0 1959920 7266440   7416 380168    0    0 11808    24  721 1217  2  1 87 10  0
 0  1 1869272 7258256   7416 471052 71724    0 71724     0 2512 4778  2  5 87  5  0
 0  1 1801124 7200844   7416 539488 57280    0 57280     0 2048 3858  0  4 88  8  0
 0  3 1748096 7180076   7428 594000 21120    0 21164  8692 1890 3519  0  3 77 20  0
 0  4 1741260 7166096   7460 603176 6880    0 10720   356  960 2134  0  1 82 17  0
 0  4 1712208 7130728   7536 632928 30064    0 31244    68 3146 9281  1  5 71 22  0
 0  2 1683784 7100300   7660 660832 31236    0 32644    64 3231 7258  0  5 84 11  0
 0  1 1626832 7042160   7684 716336 63136    0 63204     0 2766 5449  0  5 87  8  0
 0  1 1570020 6978300   7684 773016 63868    0 63868     0 2284 4316  0  4 88  8  0
 0  1 1533192 6944836   7704 811304 33440    0 33444    96 1496 2651  0  3 87 10  0
 0  1 1402664 6879132   7704 941080 65516    0 65516     0 2329 4389  1  4 88  8  0
 0  1 1372672 6841724   7712 971796 37304    0 37304    56 1569 2799  0  3 87 10  0
 1  0 1330788 6797952   7712 1013560 44356    0 44356     0 1689 3114  0  2 88 10  0
procs -----------memory---------- ---swap-- -----io---- -system-- -----cpu------
 r  b   swpd   free   buff  cache   si   so    bi    bo   in   cs us sy id wa st
 0  1 1284572 6761992   7712 1059876 35848    0 35848     0 1421 2588  0  2 87 10  0
 0  1 1234892 6723428   7712 1109148 38444    0 38444     0 1488 2711  0  3 87 10  0
 1  1 1190096 6571444   7788 1179532 36016    0 36100     0 1466 5867  6  3 82  9  0
 0  1 1146008 6503228   7840 1256876 30428    0 33832    24 1909 7419  5  3 80 11  0
 0  1 1115240 6460324   7840 1287056 37596    0 37596     0 1443 8404  3  2 84 10  0
 2  0 1022508 6424984   7840 1380024 30636    0 30636     0 1225 7257  3  3 85 10  0
 0  0 1013384 6403092   7852 1393088 3212    0  3212     0  368 2449  9  0 88  3  0
 0  1 1013384 6401604   7852 1393088    0    0     0 72076  439 1327  0  1 95  4  0
 0  1 1013384 6403588   7872 1394096    0    0     0   328  317 1526  0  0 86 13  0
 0  0 1013384 6403588   7872 1394096    0    0     0     0  260 1568  0  0 100  0  0
 0  0 1013384 6403736   7872 1394096    0    0     0     0  261 1563  0  0 100  0  0
 0  0 1013384 6403736   7872 1394096    0    0     0     0  258 1570  0  0 100  0  0

伴随着业务进程的启动，大量的数据又从交换分区换入到了内存，这个时候，也就是业务进程感觉到明显卡顿的原因了。

下面杀掉 MySQL。

# ps -ef|grep mysql
root      2658     1  0 Sep23 ?        00:00:00 /bin/sh /usr/local/mysql/bin/mysqld_safe --datadir=/data/dbdata/data --pid-file=/data/dbdata/mysql.pid
mysql    17007  2658  0 Oct10 ?        00:00:00 /usr/local/mysql/bin/mysqld --basedir=/usr/local/mysql --datadir=/data/dbdata/data --plugin-dir=/usr/local/mysql/lib/plugin --user=mysql --log-error=/data/dbdata/mysql_error.log --open-files-limit=10240 --pid-file=/data/dbdata/mysql.pid --socket=/data/dbdata/mysql.sock --port=3306
root     30613 30597  0 10:43 pts/6    00:00:00 grep mysql

# kill -9 17007
# kill -9 2658

发现他好像会自动重启

# ps -ef|grep mysql
mysql    31041     1  0 10:45 ?        00:00:00 /usr/local/mysql/bin/mysqld --basedir=/usr/local/mysql --datadir=/data/dbdata/data --plugin-dir=/usr/local/mysql/lib/plugin --user=mysql --log-error=/data/dbdata/mysql_error.log --open-files-limit=10240 --pid-file=/data/dbdata/mysql.pid --socket=/data/dbdata/mysql.sock --port=3306
root     31361 30597  0 10:46 pts/6    00:00:00 grep mysql

再杀一次

# kill -9 31041

这下可以了

# ps -ef|grep mysql
root     31435 30597  0 10:47 pts/6    00:00:00 grep mysql

顺便看一下 free

# free -m
             total       used       free     shared    buffers     cached
Mem:          7972       1557       6415          0          9       1377
-/+ buffers/cache:        169       7802
Swap:         1913        877       1036

嗯，交换分区降下去了，那么我们再次编译和运行业务进程，同时用 vmstat 进行观察。

现象一如之前，编译的时候产生大量换出

2  1 980432 6860160   1604 990932    0    0     0     0  261  303 24  1 62 13  0
 0  2 1017904 6974216   1696 963716    0    0  4652     8  447  520 10  1 76 13  0
 0  2 1127556 7007912   2252 843568    0 16240   768 16256  462  693  0  1 76 24  0
 0  6 1322852 7051004   2276 642040    0 28176  2888 40660  538  666  1  3 71 26  0
 0  5 1643840 7070812   2000 318864    0 55128  1528 55128  439  481  1  6 50 43  0
 0  3 1685084 7102164   1820 278164    0 35564   364 35568  504  508  0  1 73 25  0
 1  4 1744040 7126012   1864 218672    0 38428   148 38716  411  473  0  2 79 19  0
 0  5 1784564 7171124   1876 173576    0 52944    72 52956  416  357  0  2 71 27  0
 1  5 1795480 7174312   1968 163804    0 44836   640 46732  463  635  1  1 69 29  0
 0  6 1803120 7233380   2040 157464    0 24212   968 24220  420  451  2  1 80 17  0
 0  6 1812772 7273884   2100 147456    0 35412   184 35552  465  480  1  1 78 20  0
 0  5 1814572 7278328   2120 144904    0 6404   100  6404  482  398  0  1 76 23  0
 0  4 1815704 7295964   2152 143852    0 4148   104  4152  517  379  0  1 75 24  0
 0  3 1817916 7304692   2180 142188    0 11632   228 11640  559  546  0  1 76 23  0
 3  4 1820684 7311924   2176 137488    0 12860   180 12972  529  563  0  1 73 26  0
 0  6 1822180 7321416   2192 135088    0 6184    56  6260  461  345  0  0 76 24  0
 1  4 1829204 7345044   2208 128292    0 30316   208 30320  689  568  0  1 73 26  0
 1  3 1834580 7358464   2212 124096    0 15564   264 15564  530  570  0  1 74 25  0
 1  1 1837560 7375300   2220 120404    0 16584   312 16584  518  589  0  1 74 25  0
 1  4 1842588 7392688   2232 115984    0 16668   148 16684  555  544  0  1 75 24  0
 0  5 1846988 7384104   2248 111004    0 20672   184 20672  460  479  0  1 73 26  0
 0  5 1847640 7406224   2268 110520    0 24800   184 24824  475  500  0  1 76 23  0
 2  4 1856736 7309712   2304 101772    0 20768   564 20768  486  574 16  2 60 22  0
 1  4 1861856 7258344   2340  97444    0 5552   268  5552  551  676 11  2 57 30  0
 2  3 1864524 7121924   2364  93280    0 21484   200 21484  537  539 20  2 63 15  0
procs -----------memory---------- ---swap-- -----io---- -system-- -----cpu------
 r  b   swpd   free   buff  cache   si   so    bi    bo   in   cs us sy id wa st
 2  5 1864524 7325636   2404  96488    0 9548   288  9552  494  534 21  2 60 17  0
 1  5 1864676 7427988   2416  98824    0 7944   228  7956  480  366 12  1 64 23  0
 2  4 1864676 7191512   2444  98928    0 15584   308 19512  619  520 19  1 59 20  0
 1  5 1865156 7196544   2476  97364    0 19000    36 19164  504  351 10  2 59 30  0
 2  2 1865352 7401708   2488 101748    0 16784     4 16784  769  332 29  2 53 16  0
 3  1 1869596 7254136   2504  94632    0 31984    88 31984  600  558 27  3 55 15  0
 3  2 1872636 6989796   2524  92624    0 21340   260 21344  534  514 28  3 51 18  0
 3  3 1874220 6763748   2540  90472    0 12092     0 15864  618  292 36  2 43 20  0
 3  1 1878596 6885760   2552  89196    0 35932   720 35936  666  374 34  2 43 21  0
 4  0 1882364 6784592   2552  79056    0 14960     0 14960  610  284 36  2 50 12  0
 3  1 1886068 6999564   2428  75392    0 20904    16 20908  618  342 35  2 50 13  0
 3  1 1891016 7095012   2420  75320    0 24708   156 24708  607  394 33  3 51 14  0
 2  5 1897472 7224532   2472  83056    0 26692   300 40684  602  462 34  2 40 23  0
 1  4 1899236 7621272   2480  74012    0 10172   104 10188  645  429 20  2 29 48  0
 3  0 1899236 7153676   2508  73984    0    0    16   104  301  274 28  2 47 23  0
 3  0 1899236 7022244   2512  73980    0    0    20     0  261  298 35  2 63  0  0

启动运行的时候产生大量换入

procs -----------memory---------- ---swap-- -----io---- -system-- -----cpu------
 r  b   swpd   free   buff  cache   si   so    bi    bo   in   cs us sy id wa st
 1  0 1899236 7403648   4660 297992    0    0     0     0  259  223 12  0 88  0  0
 0  1 1899236 7565008   4976 306928    0    0   436     0  330 1062  9  1 88  3  0
 1  0 1899236 7436296   6792 316420    0    0 11856     0  725 1185  2  1 87 10  0
 0  1 1844588 7368352   6792 371932 64928    0 64928     0 2289 4303  2  4 88  6  0
 0  1 1792108 7365004   6800 424200 67024    0 67024    48 2922 5579  0  5 87  8  0
 0  3 1777704 7346276   6820 439524 18592    0 18616  8844 1469 2551  0  2 84 14  0
 1  2 1754960 7317704   6948 464576 24292    0 26588     0 2535 5185  0  3 84 12  0
 1  1 1732796 7292252   7020 486816 23500    0 24356     0 2402 4492  0  2 87 10  0
 1  0 1716448 7267476   7060 503880 28056    0 28448     0 2249 3774  0  3 87 10  0
 0  1 1673680 7222296   7060 546672 45176    0 45176     0 1681 3091  0  2 88 10  0
 0  1 1647400 7188072   7060 572704 34172    0 34172     0 1339 2382  0  2 87 10  0
 1  0 1612980 7144300   7060 606688 43644    0 43644     0 1631 2995  0  2 88 10  0
 0  1 1576360 7094080   7060 643304 50344    0 50344     0 1864 3426  0  4 87  9  0
 0  1 1540148 7044420   7060 680128 49760    0 49760     0 1863 3430  0  3 88  9  0
 0  1 1511728 7005112   7068 708428 39176    0 39176    28 1584 2837  0  3 87 10  0
 0  1 1475812 6960720   7068 744108 44440    0 44440     0 1650 3028  0  3 87  9  0
 0  1 1445400 6925256   7068 774252 35256    0 35256     0 1377 2470  0  2 88 10  0
 1  0 1416776 6895156   7068 803572 30140    0 30140     0 1255 2221  0  2 87 10  0
 1  0 1392580 6871472   7068 827836 23576    0 23576     0  998 1716  0  2 88 10  0
 0  1 1364792 6832536   7068 854968 38692    0 38692     0 1481 2677  0  3 87 10  0
 0  1 1336872 6794964   7068 883056 37836    0 37836     0 1446 2603  0  2 87 10  0
 0  1 1277036 6770660   7068 943312 24252    0 24252     0 1025 1774  0  2 88 11  0
 0  1 1248952 6740528   7076 971268 29932    0 29932    24 1306 2309  0  2 86 12  0
 0  1 1206072 6708412   7076 1014120 31896    0 31896     0 1270 2254  0  1 88 11  0
 0  2 1152052 6578112   7116 1068260 43016    0 43080     0 1623 4425  3  3 85  8  0
 0  2 1129556 6508608   7204 1136560 18872    0 18976     0 1370 3832  5  3 79 13  0
 2  0 1084612 6469112   7224 1199936 19616    0 22968     0 1187 6305  3  2 84 11  0
 0  1 1057784 6442944   7248 1226144 22152    0 22276     0 1048 5929  2  2 85 11  0
 0  1 967744 6424096   7248 1316964 15668    0 15696     0  892 5197  1  2 86 11  0
 1  1 898092 6394212   7260 1386324 14672    0 14672 37396 1257 5781  8  3 83  6  0
 0  1 898092 6387144   7288 1389380    0    0    12 31572  481 1601  3  1 84 13  0
 0  0 898092 6387144   7288 1389380    0    0     0     0  262 1582  0  0 93  7  0

看来杀 MySQL 也没有用啊。

继续搜，看到这里，http://askubuntu.com/questions/157793/why-is-swap-being-used-even-though-i-have-plenty-of-free-ram?，提到一个叫 swappiness 的东西

What is swappiness and how do I change it?
The swappiness parameter controls the tendency of the kernel to move processes out of physical memory and onto the swap disk. Because disks are much slower than RAM, this can lead to slower response times for system and applications if processes are too aggressively moved out of memory.

swappiness can have a value of between 0 and 100

swappiness=0 tells the kernel to avoid swapping processes out of physical memory for as long as possible

swappiness=100 tells the kernel to aggressively swap processes out of physical memory and move them to swap cache

The default setting in Ubuntu is swappiness=60. Reducing the default value of swappiness will probably improve overall performance for a typical Ubuntu desktop installation. A value of swappiness=10 is recommended, but feel free to experiment. Note: Ubuntu server installations have different performance requirements to desktop systems, and the default value of 60 is likely more suitable.

To check the swappiness value

cat /proc/sys/vm/swappiness

To change the swappiness value A temporary change (lost on reboot) with a swappiness value of 10 can be made with

sudo sysctl vm.swappiness=10

To make a change permanent, edit the configuration file with your favorite editor:

gksudo gedit /etc/sysctl.conf

Search for vm.swappiness and change its value as desired. If vm.swappiness does not exist, add it to the end of the file like so:

vm.swappiness=10

Save the file and reboot.

然而，当我查看我的环境的这个变量的时候，却是这个样子

$ cat /proc/sys/vm/swappiness
10

这是在逗我吗。。

到此为止，好像走进了一个绝路，那么我们回头整理一下思路，从最开始的发现物理内存为空，交换分区满，于是我们去查什么东西占用交换分区，用了各种或直接或间接的方法查，然后逐个杀掉了 java 和 MySQL，到这个时候，我们依然相信系统对于内存的管理是没有异常的，而是由于我们的某些特殊场景，导致了物理内存空交换分区满的现象，然而，在 java 和 MySQL 都先后杀掉以后，物理内存和交换分区都腾空出来了，再次操作依然可以发现系统在物理内存空的时候大量操作交换分区，到这个时候，我们就开始怀疑系统对于内存的管理出现了问题，然而，通过一些简单的排查，发现系统的 swappiness 分配参数也是没有问题的，那么，问题出在哪里呢。

在刚刚那个页面，继续往下看，有看到用 swapoff 和 swapon 来开关交换分区的，这招可谓是釜底抽薪，那我们来试一下，swapoff -a 同时，用 vmstat 进行观察

$ vmstat 1
procs -----------memory---------- ---swap-- -----io---- -system-- -----cpu------
 r  b   swpd   free   buff  cache   si   so    bi    bo   in   cs us sy id wa st
 1  2 420968 6591000    636 1468136    3    3     8     6    0    0  0  0 99  0  0
 0  2 400720 6570968    440 1488896 20248    0 20252     0 5327 10388  0 10 75 15  0
 0  2 377560 6549048    388 1510540 23156    0 23164     4 6055 12964  0 10 74 16  0
 1  1 350740 6522324    368 1537300 26812    0 26812     8 6966 14147  0 11 75 14  0
 1  1 321720 6493740    368 1565100 28984    0 28992    56 7523 16173  0 10 74 16  0
 1  1 295620 6468000    372 1590800 26096    0 26100     0 6788 13731  0 11 74 15  0
 0  2 269620 6449592    376 1611356 26000    0 26432     4 6778 14532  0 11 74 15  0
 1  1 242364 6422372    372 1638092 27252    0 27832     4 7099 15180  0 12 74 14  0
 0  4 222304 6400124    400 1658648 20032    0 24044     0 5331 11827  0  9 74 17  0
 1  1 199892 6378832    396 1680272 22384    0 22388    28 5871 12186  0 10 76 14  0
 1  1 178436 6360520    392 1697836 21372    0 22724     4 5627 11596  0 10 76 14  0
 1  1 150812 6334388    376 1724580 27624    0 28172     0 7181 14521  0 10 75 15  0
 1  1 120884 6304084    380 1753372 29916    0 31000     8 7767 17782  0 10 73 17  0
 1  1  82764 6267040    380 1791408 38120    0 38120     0 9790 19308  0 10 75 15  0
 1  1  48192 6232144    380 1826360 34572    0 35068     0 8912 18106  0 12 74 13  0
 1  1  15452 6198328    384 1859264 32728    0 34568     0 8487 19192  0 10 72 18  0
 0  1      0 6180212    416 1877740 15444    0 20384     0 4233 8065  0  5 79 16  0
 0  2      0 6177676    556 1879656    0    0  7076    24  531  509  0  1 81 18  0
 2  3      0 6168072    868 1884484    0    0  7232     0  486 1164  0  1 78 21  0
 1  0      0 6167860    956 1889536    0    0  4792     0  372 1166  0  1 81 18  0
 0  1      0 6176860    664 1880576    0    0   836     0  276  258  0  1 87 12  0

可以看到系统大量的 IO，把交换分区里面的东西统统挪到了物理内存上，完了之后，我们看一下 free

$ free -m
             total       used       free     shared    buffers     cached
Mem:          7972       1936       6036          0          0       1829
-/+ buffers/cache:        106       7866
Swap:            0          0          0

嗯，我们还有 6G 的物理内存，那么重新编译和运行业务进程，看看是个什么情况

procs -----------memory---------- ---swap-- -----io---- -system-- -----cpu------
 r  b   swpd   free   buff  cache   si   so    bi    bo   in   cs us sy id wa st
 3  1      0 5468392    916 1901912    0    0   268     4  305  406 31  2 52 14  0
 3  1      0 5198028    924 1900876    0    0   124     0  276  267 36  1 50 13  0
 3  2      0 5613288    844 1897872    0    0   740 10320  431  521 31  3 49 17  0
 3  1      0 5308244    812 1898932    0    0   412     4  276  287 32  2 52 14  0
 3  1      0 5112304    816 1897900    0    0   504     0  318  278 36  1 50 13  0
 3  1      0 5824276    832 1906108    0    0  2312     8  390  461 29  4 52 15  0
 3  1      0 5386064    784 1904100    0    0   428     8  282  258 36  2 50 13  0
 2  2      0 5383212    724 1903132    0    0   220  7544  350  409 34  2 46 17  0
 3  1      0 5608280    712 1906228    0    0  1984     8  367  403 33  3 50 14  0
 3  1      0 5576976    768 1905144    0    0   464     8  309  364 35  1 49 14  0
 3  1      0 5271180    804 1907164    0    0    56     0  275  285 35  1 50 14  0
 0  4      0 6092084    828 1905084    0    0  2572     8  437  750 23  4 53 21  0
 2  3      0 5932212    844 1899928    0    0  1000 11032  444 1112  7  2 66 25  0
 0  3      0 6045028    980 1901848    0    0  2532     0  381  619  9  1 64 26  0
 4  0      0 5863828   1064 1898680    0    0  1124    44  393  770  7  1 65 27  0
 3  1      0 5564052   1032 1900768    0    0  3088     0  337  374 35  3 50 12  0
 3  1      0 5625928   1096 1903788    0    0   440     4  326  399 34  2 52 12  0
 3  1      0 5571116    808 1898936    0    0   716  3508  381  431 34  2 47 17  0

可以看到编译过程中，内存占用大约在 500-800MB 左右波动，这个可以理解和接受，然后看启动起来

$ vmstat 1
procs -----------memory---------- ---swap-- -----io---- -system-- -----cpu------
 r  b   swpd   free   buff  cache   si   so    bi    bo   in   cs us sy id wa st
 0  1      0 6180156    384 1875716    3    3     8     6    0    0  0  0 99  0  0
 0  1      0 6180336    404 1876724    0    0   788     0  309  292  0  0 87 12  0
 1  2      0 6178192    628 1876500    0    0  3988     0  449  521  0  0 86 14  0
 0  2      0 6171380    652 1882644    0    0 10388     0  576  621  0  1 83 15  0
 0  3      0 6096204    720 1893884    0    0 11724     0  395  480  5  2 80 13  0
 1  1      0 5972932    960 1929624    0    0  2836     4  411 2259  5  2 73 20  0
 0  3      0 5913788   1308 1971424    0    0  9456     0  496 3027 10  1 67 21  0
 0  3      0 5900968   1112 1969564    0    0  4260 42588  576 1657  8  1 73 18  0
 0  6      0 5903616   1028 1965536    0    0  2940 26108  512 1623  0  1 74 25  0
 0  8      0 5946120    800 1924644    0    0  2276     0  368 1297  0  1 81 18  0
 1  3      0 5966924    844 1904040    0    0  2208     0  353 1731  0  1 82 18  0
 0  2      0 5980372   1024 1895636    0    0  4060   388  352 1801  0  1 80 20  0
 0  1      0 5983440   1032 1894600    0    0  1404    44  333 1690  0  0 86 13  0
 0  1      0 5984280   1048 1892528    0    0  1136  3556  310 1663  0  0 86 13  0
 0  1      0 5984124   1036 1892540    0    0   920    36  287 1641  0  0 88 12  0
 0  1      0 5989944    920 1887516    0    0   408   136  304 1651  0  0 88 12  0
 0  1      0 5991924    908 1886500    0    0     8     4  262 1646  0  0 87 12  0
 0  1      0 5992576    756 1885624    0    0  1060    96  329 1635  0  0 87 13  0
 0  1      0 5996540    724 1881544    0    0     0    28  270 1553  0  0 88 12  0
 0  1      0 5997800    488 1880752    0    0     0    40  265 1528  0  0 87 12  0
 0  1      0 5998040    416 1879796    0    0     0    24  266 1542  0  0 87 12  0

进程启动起来大约只耗用 200MB 的内存，而且关键的是，现在业务进程不卡了，这个是一个重大突破啊。

随后发现一个问题，负载持续在 1 左右，下不去

# uptime
  3:53pm  up 21 days  5:08,  11 users,  load average: 1.65, 1.20, 1.11

看了一下 top，是一个叫 kswapd0 的进程在跑 CPU，查了一下，看到这里，http://my.oschina.net/davehe/blog/83023?，说是这个是一个管理虚拟内存的，那应该也可以一并干掉

# ps -ef|grep swap
root       368     1  0 Sep23 ?        00:18:43 [kswapd0]
root     28397 30597  0 16:03 pts/6    00:00:00 grep swap
# kill -9 368

发现杀不掉，那个进程的名字带了中括号，看这里，http://www.cnblogs.com/vamei/archive/2012/09/20/2694466.html?，

第三列有一些由中括号[]括起来的。它们是kernel的一部分功能，被打扮成进程的样子以方便操作系统管理。我们不必考虑它们。

真是个悲剧。

不过，问题到这里，其实只是治标不治本，本着 no zuo no die 的精神，我们把交换分区再次打开。

# swapon -a

一打开，立刻交换分区就用上了

$ free -m
             total       used       free     shared    buffers     cached
Mem:          7972        669       7303          0          1        137
-/+ buffers/cache:        530       7441
Swap:         1913       1721        192

同时，系统负载也下来了

# uptime
  4:26pm  up 21 days  5:42,  11 users,  load average: 0.06, 0.59, 0.88

感觉就像是 kswapd0 卯足了劲想把物理内存里面的东西搬到交换分区去，当交换没门的时候他一直耗着 CPU，门一开他立刻撒了欢的搬东西到交换分区，然后就心满意足的歇息了。

药不能停啊。。

不管怎么说，有了新的线索，那么我们换个方向，重新放狗，搜出来第一条，http://www.gossamer-threads.com/lists/gentoo/user/286725?，就说：

Q1: Why does the kswapd0 process from time to time take up 100% CPU?

I can’t answer this, other than say that something is using up your memory and the kernel is processing heavily (assessing) the number of free pages in the system to see if they are getting too low and therefore it should start swapping pages out into your swap partition. It runs on a timer, so it will check this every now and then and therefore you will find it fluctuates over time.

在这里，http://forums.debian.net/viewtopic.php?f=5&t=107621?，一大坨同学们在热烈的讨论，这位哥们遭受的情况可比我悲催多了，被卡住都是 hours 的，卡到连终端都登不上，而且在 swap 的时候还会 swap 到系统崩溃掉，真是可怜，来看看他具体是怎样的：

- The system starts swapping highly erratic, no matter what swappiness value is set. On the one hand 99% of memory can be in use without swapping for a long time but on the other it suddenly swaps when only using a fraction of it. - When it swaps ist swaps almost everything. Sometimes really everything. The memory usage will drop to a few percent. After that the process is reversed and the swapped data is read into memory again (at least parts of it). Until there’s about the same percentage of ram and swap in use. - It seems to swap the cached/buffered data too (but it might only seem that way) - After standby it almost always start so swap within the first minute. No matter how much memory is actually used. So before going into standby I have to kill most of the programms if I don’t want to wait hours (no kidding, it’s really hourse. See next point) for it to finish. It does so even if standby mode lasted for only 1 second. Maybe the system gets confused and thinks the data is all very old? - Swapping uses a lot, really a lot of resources and freezes the whole computer. Happend to only swap about 100 MB but the pc was frozen for an hour with the swap process using all cpu and all IO resources - even on new hardware. I don’t know what it does, but I can encrypt a whole harddisk in a fraction of this time. Even login on console isn’t possible anymore (timeout). After waking up from standy this results in a black screen until it’s finished (which may take half an hour, 1 hour or even forever, see below). - The swap process starts without even using swap. I’ve currently no swap partition/file in use and even turned swappiness to 0. Still the process kicks in from time to time, using a lot of cpu and 99% of IO (according to iotop), slowing down the whole PC. Even happens with 2GB of 3,5GB Ram unused (except for cache). This espacially happens when I’m copying some files. I guess the swap process kicks in since it thinks that all the cached/buffered data is actual memory usage and wants to swap it. But since there’s no swap the process randomly access all my harddisks. Don’t know why, maybe it’s looking for something swap-like. - Sometimes the swap process seems to be cought in some form of loop. Even without swap being installed. The process is taking all of the recourses and won’t stop. There’s no other way than a hardcore shutdown (unplugging power or pressing power button for 4 secs). Even the magic SysRq key fails. - While it swaps parts of the system may crash, like the file browser or even kernel modules. Very often I have to manually modprobe psmouse to use the mouse pointer again since it stays frozen.

真是有够惨的，一楼的回复建议重新编译内核，这。。顺道记录一下我的环境的版本，是 tlinux 的 2.6.16.60-0.21 的 64 位版本。

这么看来，就应该是一个内核的问题了。于是开始寻求 tlinux 开发支持同学的帮助。

一开始，tlinux 的同学也提出了跟我最初类似的想法，就是交换分区的东西是被一些特殊场景“挤”到虚拟内存，然后又一直没有被 touch，所以一直留在物理内存里面，但是我提出的 swapoff 和 swapon 的现象之后这个假设也可以简单的验证为不成立。于是他们又另外去查，最后查到是 min_free_kbytes 这个参数，被设置为 5G

# cat -n /etc/sysctl.conf | grep min_free_kbytes
    39	vm.min_free_kbytes=5000000

这个参数从字面意思也很好理解，看到这里，https://my.vertica.com/docs/7.1.x/HTML/Content/Authoring/InstallationGuide/BeforeYouInstall/min_free_kbytes.htm?，提供了一个这个值的参考配置方法，是将总的内存数乘以 16 再开根号

To manually set min_free_kbytes:

Determine the current/default setting with the following command:
/sbin/sysctl vm.min_free_kbytes
If the result of the previous command is No such file or directory or the default value is less than 4096, then run the command below:
memtot=`grep MemTotal /proc/meminfo | awk '{printf "%.0f",$2}'`
echo "scale=0;sqrt ($memtot*16)" | bc
Edit or add the current value of vm.min_free_kbytes in /sbin/sysctl.conf with the value from the output of the previous command.

# The min_free_kbytes setting

vm.min_free_kbytes=5572

Run sysctl -p to apply the changes in sysctl.conf immediately.

Note: These steps will need to be replicated for each node in the cluster.

按照这个方法，修改配置文件，将值改为 11428，然后让配置生效

# sysctl -p

立刻就可以看到交换分区的使用降下来了

# free -m
             total       used       free     shared    buffers     cached
Mem:          7972       1970       6001          0          0       1836
-/+ buffers/cache:        133       7839
Swap:         1913          0       1913

再次编译和运行业务进程，也没有卡顿，系统负载也正常，至此，问题终于解决。

痛定思痛，关于虚拟内存的系统参数，到底都有哪些呢，看到这里，https://access.redhat.com/documentation/en-US/Red_Hat_Enterprise_Linux/6/html/Performance_Tuning_Guide/s-memory-tunables.html?，里面提出了很多：

5.5.?Tuning Virtual Memory

Virtual memory is typically consumed by processes, file system caches, and the kernel. Virtual memory utilization depends on a number of factors, which can be affected by the following parameters.

swappiness

A value from 0 to 100 which controls the degree to which the system swaps. A high value prioritizes system performance, aggressively swapping processes out of physical memory when they are not active. A low value prioritizes interactivity and avoids swapping processes out of physical memory for as long as possible, which decreases response latency. The default value is 60.

A high swappiness value is not recommended for database workloads. For example, for Oracle databases, Red?Hat recommends a swappiness value of 10.
vm.swappiness=10
min_free_kbytes

The minimum number of kilobytes to keep free across the system. This value is used to compute a watermark value for each low memory zone, which are then assigned a number of reserved free pages proportional to their size.

Extreme values can break your system

Be cautious when setting this parameter, as both too-low and too-high values can be damaging.

Setting min_free_kbytes too low prevents the system from reclaiming memory. This can result in system hangs and OOM-killing multiple processes.

However, setting this parameter to a value that is too high (5-10% of total system memory) will cause your system to become out-of-memory immediately. Linux is designed to use all available RAM to cache file system data. Setting a high min_free_kbytes value results in the system spending too much time reclaiming memory.

dirty_ratio

Defines a percentage value. Writeout of dirty data begins (via pdflush) when dirty data comprises this percentage of total system memory. The default value is 20.

Red?Hat recommends a slightly lower value of 15 for database workloads.

dirty_background_ratio

Defines a percentage value. Writeout of dirty data begins in the background (via pdflush) when dirty data comprises this percentage of total memory. The default value is 10. For database workloads, Red?Hat recommends a lower value of 3.

dirty_expire_centisecs

Specifies the number of centiseconds (hundredths of a second) dirty data remains in the page cache before it is eligible to be written back to disk. Red?Hat does not recommend tuning this parameter.

dirty_writeback_centisecs

Specifies the length of the interval between kernel flusher threads waking and writing eligible data to disk, in centiseconds (hundredths of a second). Setting this to 0 disables periodic write behavior. Red?Hat does not recommend tuning this parameter.

drop_caches

Setting this value to 1, 2, or 3 causes the kernel to drop various combinations of page cache and slab cache.

1

The system invalidates and frees all page cache memory.

2

The system frees all unused slab cache memory.

3

The system frees all page cache and slab cache memory.

This is a non-destructive operation. Since dirty objects cannot be freed, running sync before setting this parameter’s value is recommended.

Important

Using the drop_caches to free memory is not recommended in a production environment.

To set these values temporarily during tuning, echo the desired value to the appropriate file in the proc file system. For example, to set swappiness temporarily to 50, run:
# echo 50 > /proc/sys/vm/swappiness
To set this value persistently, you will need to use the sysctl command.

需要注意的是，在调那个 min_free_kbytes 的参数时，过大或者过小，都是有问题的

历史评论

wanax (2014-10-10 13:55:03):

这篇文章写得很不错啊

ZRJ (2014-10-10 14:21:53):

还没写完，事情处理到这儿，没思路了，我是先贴个半成品出来，让另外一个朋友帮我看看

pishuang (2016-04-19 11:50:07):

博主写的非常不错！我说一下我的理解吧，在设置了vm.swapness=0这个参数之后systcl -p，重启第一个脚本里列出来的非系统进程，其实就可以释放内存了，尤其是重启mysql的时候，free -m 可以明显的感觉swap的空间在下降，那是因为mysql将内存中的相关数据刷到了磁盘上，重启过程中会释放内存。vm.swapness这个参数的值是可用内存小于总内存的百分之多少使用swap分区，默认的是60，也就说系统判断可用内存小于60%就会启用swap内存，所以你那个JAVA的进程一启动的时候其实就已经占用了50%的内存空间，就会导致后面的问题。

ZRJ (2016-04-19 18:56:45):

这么长的文章居然看了，也是不容易，哈哈

pishuang (2016-04-19 19:40:16):

由一个问题引出更多的问题并给出解释，不得不让人看到最后啊。

ZRJ (2016-04-20 08:23:40):

哈哈，也就当年不忙的时候能这么记录，现在遇到问题都是速战速决了

CZL (2019-01-10 10:22:37):

写得很详细，帮我解决了问题，感谢

ZRJ (2019-01-10 15:38:24):

嘿嘿

jcren (2019-04-29 09:00:46):

没能解决问题，但是感觉作者写的好棒，谢谢~

使用 raw socket 来躲开 netstat 的连接监控

Mon, 01 Sep 2014 09:45:03 +0800

先来看一个非常普通的收发

服务端

#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <assert.h>

int main() {
    int listen_fd = socket(AF_INET, SOCK_DGRAM, 0);
    assert(listen_fd > 0);
    struct sockaddr_in listen_addr;
    memset(&listen_addr, 0, sizeof(listen_addr));
    listen_addr.sin_family = AF_INET;
    listen_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    listen_addr.sin_port = htons(9999);
    assert(bind(listen_fd, (struct sockaddr*)&listen_addr, sizeof(listen_addr)) != -1);
    while (1) {
        struct sockaddr_in cli_addr;
        memset(&cli_addr, 0, sizeof(cli_addr));
        socklen_t cli_addr_len = sizeof(cli_addr);
        int msg, msg_len;
        recvfrom(listen_fd, &msg, sizeof(msg), 0, (struct sockaddr*)&cli_addr, &cli_addr_len);
        printf("%d\n", msg);
        sleep(1);
        msg++;
        sendto(listen_fd, &msg, sizeof(msg), 0, (struct sockaddr*)&cli_addr, cli_addr_len);
    }
    return 0;
}

客户端

#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <assert.h>

int main() {
    int socket_fd = socket(AF_INET, SOCK_DGRAM, 0);
    assert(socket_fd > 0);
    struct sockaddr_in serv_addr;
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(9999);
    assert(inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr) >= 0);
    int msg = 1;
    while (1) {
        sendto(socket_fd, &msg, sizeof(msg), 0, (struct sockaddr*)&serv_addr, sizeof(serv_addr));
        socklen_t serv_addr_len = sizeof(serv_addr);
        recvfrom(socket_fd, &msg, sizeof(msg), 0, (struct sockaddr*)&serv_addr, &serv_addr_len);
        printf("%d\n", msg);
        sleep(1);
        msg++;
    }
    return 0;
}

跑起来之后，可以用 netstat -anp|grep 9999 看到下面的链接

(Not all processes could be identified, non-owned process info
 will not be shown, you would have to be root to see it all.)
udp        0      0 0.0.0.0:9999            0.0.0.0:*                           16144/ser

问题来了，如果我不想被 netstat 看到，需要怎么搞呢

这个思路其实比较直接，就是使用 raw socket，注意到 netstat 是分析 tcp 或者 udp 包头中的 port 字段来判定这个是个什么样的连接的，所以如果我们使用一个自定义的传输层协议，然后自行填充 ip 包的包头，发送出去，就可以绕过 netstat 的检查了。

说起来容易，但是实际调起来发现 raw socket 确实是不好调，稍后代码如果能调通了会放一份上来。

可以看这里有相关的说明，http://sec.chinabyte.com/429/8835429.shtml

历史评论

LIANG YUQING (2014-11-27 14:39:33):

不过楼主的目的是要创建一种属于自己的protocol，这样就不会受到TCP/UDP监控？有种covert channel的感觉…

ZRJ (2014-11-28 09:22:02):

是的，可以看我原文最后引用的那篇文章，里面有说明，这种技术一般是木马用于躲避简单的监控

ctime 可重入问题引起的死锁

Wed, 13 Aug 2014 10:42:57 +0800

遇到一个死锁，堆栈类似如下

#0 0x00002b6b7d16cc38 in __lll_mutex_lock_wait () from /lib64/libc.so.6
#1 0x00002b6b7d126a9d in _L_lock_1769 () from /lib64/libc.so.6
#2 0x00002b6b7d126876 in __tz_convert () from /lib64/libc.so.6

搜了一下，发现之前有人已经讨论过这个问题了，在这里，http://lists.gnu.org/archive/html/help-gplusplus/2008-09/msg00006.html ，他给出了一个样例程序如下

#include <sys/time.h>
#include <time.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>

volatile char *r;

void handler(int sig)
{
time_t t;

time(&t);
r = ctime(&t);
}

int main()
{
struct itimerval it;
struct sigaction sa;
time_t t;
int counter = 0;

memset(&sa, 0, sizeof(sa));
sa.sa_handler = handler;
sigaction(SIGALRM, &sa, NULL);

it.it_value.tv_sec = 0;
it.it_value.tv_usec = 1000;
it.it_interval.tv_sec = 0;
it.it_interval.tv_usec = 1000;
setitimer(ITIMER_REAL, &it, NULL);

while(1) {
counter++;
time(&t);
r = ctime(&t);
printf("Loop %d\n",counter);
}

return 0;
}

这个程序可以稳定的重现死锁的问题，gdb attach 上去之后看到的堆栈也是类似的，一开始以为是 ctime 的可重入问题，觉得改成 ctime_r 就可以很容易的解决，动手之后发现修改 ctime_r 并不奏效

另外，下面这个代码，却又不会引起死锁

#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <stdlib.h>

int i = 0;
volatile char* r;

void* thread(void*) {
    while (1) {
        time_t t = time(NULL);
        r = ctime(&t);
        printf("%d\n", i++);
    }
    return NULL;
}

int main() {
    pthread_t tid;
    for (int j = 0; j < 100; j++) {
        pthread_create(&tid, NULL, thread, NULL);
    }
    sleep(1);
    return 0;
}

在其他地方，也有见到类似的讨论，例如这里，https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=687582 ，说道

According to signal(7), ctime is not safe to be called from a signal handler (nor, more generally, are malloc or free). Probably debug messages from signal handler context should not attempt to display the time, or should use some built-in time implementation that doesn’t malloc or care about timezones, or something.

另外，这里，http://stackoverflow.com/questions/11933212/what-could-cause-a-deadlock-between-time-functions-and-dll-loading ，https://bugzilla.redhat.com/show_bug.cgi?id=491637 ，https://bugzilla.redhat.com/show_bug.cgi?id=152319 ，也都有讨论

现在的问题是

为什么在那个信号处理的例子中会死锁，而多线程的不会
对于死锁的那个例子，怎么避免

经过 kamus 大哥指点，这个其实不是 ctime 本身的问题，而是 ctime 内部使用了 malloc，通过 strace 分析可以发现 ctime 的系统调用如下

brk(0) = 0x501000
brk(0x522000) = 0x522000
open("/etc/localtime", O_RDONLY) = 3
fstat(3, {st_mode=S_IFREG|0644, st_size=165, ...}) = 0
fstat(3, {st_mode=S_IFREG|0644, st_size=165, ...}) = 0
mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x2b5a8a93c000
read(3, "TZif\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\3\0\0\0\3\0"..., 4096) = 165
close(3) = 0
munmap(0x2b5a8a93c000, 4096) = 0

至于信号处理和多线程，这个就跟递归是类似，不能递归的对同一把锁上锁，但是可以多线程对同一把锁上锁，只要其他线程稍后把这个锁释放了就可以了，最后，解决方法就是，不要在信号处理的函数中使用 ctime 或者 malloc 之类的函数。

Linux 分页的一份 pdf

Fri, 18 Jul 2014 10:47:55 +0800

近来在看 linux 的一些分页相关的说明资料，在这里，http://www.kerneltravel.net/chenlj/lecture5.pdf，最后有一节，Linux 系统地址映射举例，通过实例的方式介绍了分页的一些实现，记下备忘。

Python 脚本依赖 glob 从命令行获取通配符文件名

Tue, 06 May 2014 10:07:17 +0800

在写一个 py 脚本的时候，需要从命令行里面带参数进来，指明需要处理的文件名，这个地方，希望支持 shell 那种 * 的通配符，查了一下，有相关的库，看这里，https://docs.python.org/2/library/glob.html

但是，按照这种搞法，跑起来之后发现不行，glob.glob(sys.argv[2]) 总是只返回一个文件名，查了一下，看到这里，http://stackoverflow.com/questions/8538564/pythons-glob-only-returning-the-first-result

原来，是我们在使用 shell 的时候，在 * 送给到 py 脚本之前，就已经被展开了，那么怎么办呢，原题给了一个方式，说用引号引起来，不过还有另外一种方式，可以遍历 sys.argv 数组

if __name__ == "__main__":
    if len(sys.argv) < 3:
        print "Usage:", sys.argv[0], "path_to_ini path_to_dump_file"
    else:
        for path_to_dump in sys.argv[2:]:
            if os.path.isdir(path_to_dump):
                print path_to_dump, "is a directory, skip..."
            else:
                split(sys.argv[1], path_to_dump)

tr1 的 unorderd_map

Thu, 24 Apr 2014 11:17:15 +0800

#include <tr1/unordered_map>
#include <stdio.h>
#include <string>

int main() {
    typedef std::tr1::unordered_map<std::string, int> HashMap;
    HashMap mapNumber;
    mapNumber["one"] = 1;
    mapNumber["two"] = 2;
    std::tr1::hash<std::string> hashFunc = mapNumber.hash_function();
    for (HashMap::const_iterator it = mapNumber.begin();
            it != mapNumber.end(); it++) {
        printf("%s(hash code: %d) -> %d\n", it->first.c_str(),
                hashFunc(it->first), it->second);
    }
    return 0;
}

two(hash code: 1149015817) -> 2
one(hash code: 566910127) -> 1

如果需要自定义类型，可以看这里，http://hi.baidu.com/wewe39/item/c342d5f48cb25d0ec6dc45a9

稍后做一下和 std::map 的查找效率对比

-————————-

2014-4-24 13:03:39 update

刚刚看了一下效率对比

#include <tr1/unordered_map>
#include <map>
#include <stdio.h>
#include <string>
#include <sys/time.h>
#include <time.h>
#include <stdlib.h>

std::map<std::string, int> rbtreeMap;
std::tr1::unordered_map<std::string, int> hashMap;

void printtime() {
    struct timeval tm;
    gettimeofday(&tm, NULL);
    printf("%lu, %lu\n", tm.tv_sec, tm.tv_usec);
}

void initRbtreeMap(int init_count) {
    for (int i = 0; i < init_count; i++) {
        int r = rand() % init_count;
        char str[16] = {0};
        snprintf(str, sizeof str, "%d", r);
        rbtreeMap[str] = r;
    }
    printf("rb tree map size %d\n", rbtreeMap.size());
}

void initHashMap(int init_count) {
    for (int i = 0; i < init_count; i++) {
        int r = rand() % init_count;
        char str[16] = {0};
        snprintf(str, sizeof str, "%d", r);
        hashMap[str] = r;
    }
    printf("hash map size %d\n", hashMap.size());
}

void testRbtreeMap(int init_count, int test_count) {
    int hit = 0, miss = 0;
    for (int i = 0; i < test_count; i++) {
        int r = rand() % init_count;
        char str[16] = {0};
        snprintf(str, sizeof str, "%d", r);
        if (rbtreeMap.find(str) == rbtreeMap.end()) {
            miss++;
        } else {
            hit++;
        }
    }
    printf("rb tree hit count %d miss count %d\n",
            hit, miss);
}

void testHashMap(int init_count, int test_count) {
    int hit = 0, miss = 0;
    for (int i = 0; i < test_count; i++) {
        int r = rand() % init_count;
        char str[16] = {0};
        snprintf(str, sizeof str, "%d", r);
        if (hashMap.find(str) == hashMap.end()) {
            miss++;
        } else {
            hit++;
        }
    }
    printf("hash tree hit count %d miss count %d\n",
            hit, miss);
}

int main() {
    srand(time(NULL));
    int init_count = 500 * 1000;
    printtime();
    initRbtreeMap(init_count);
    printtime();
    initHashMap(init_count);
    printtime();
    int test_count = 10 * 1000 * 1000;
    testRbtreeMap(init_count, test_count);
    printtime();
    testHashMap(init_count, test_count);
    printtime();
    return 0;
}

1398315723, 65363
rb tree map size 316072
1398315724, 33265
hash map size 316202
1398315724, 423226
rb tree hit count 6320750 miss count 3679250
1398315743, 283560
hash tree hit count 6323107 miss count 3676893
1398315748, 386742

tr1 的 bind 和 function

Fri, 18 Apr 2014 16:36:37 +0800

首先来看两个文章，function/bind的救赎（上），http://blog.csdn.net/myan/article/details/5928531，以boost::function和boost:bind取代虚函数，http://blog.csdn.net/solstice/article/details/3066268，前者讲背景和理论，后者讲实际操作和细节对比，读来酣畅淋漓，醍醐灌顶

这么好的东西，当然要想着怎么在现有的环境条件下用起来，没有 boost，但是幸运的是这东西已经进了 tr1，那么可以这么来

#include <stdio.h>
#include <tr1/functional>

using std::tr1::function;
using std::tr1::bind;
using std::tr1::placeholders::_1;

class Foo {
public:
    void methodA() {
        printf("method a\n");
    }
    void methodInt(int a) {
        printf("method int %d\n", a);
    }
};

class Bar {
public:
    void methodB() {
        printf("method b\n");
    }
};

int main() {
    Foo foo;
    function<void()> f1 = bind(&Foo::methodA, &foo);
    f1();

    Bar bar;
    f1 = bind(&Bar::methodB, &bar);
    f1();
    
    f1 = bind(&Foo::methodInt, &foo, 42);
    f1();
    
    function<void(int)> f2 = bind(&Foo::methodInt, &foo, _1);
    f2(53);
    
    return 0;
}

得到输出

method a
method b
method int 42
method int 53

真是好用，不过需要注意的一点就是带了 tr1/functional 这东西之后，编译速度明显下来了很多

-————————————————————-

2014-04-19 20:34:37 update

跟同学讨论之后，发现这个东西，其实可以这么来模拟

#include <stdio.h>

typedef void (*fun)(void *, int, int);    

class Foo
{
private:
    void add(int a, int b)
    {
	printf("%d\n", a+b);
    }
public:
    fun mybind()
    {
	fun f = (fun)&Foo::add;
	return f;
    }
};

int main(int argc, char **argv)
{
    Foo foo;    
    fun f = foo.mybind();
    f(&foo, 1, 2);
    return 0;
}

看，虽然 add 是个私有函数，但是我们可以把他偷换出来，在外面去调用，不过需要注意，这个代码编译是有警告的

历史评论

ZRJ (2014-04-18 16:46:01):

http://blog.csdn.net/jnu_simba/article/details/12944043 这个也不错

wanax (2014-04-21 12:11:04):

面向类设计的癌症赞

tian (2014-04-30 17:17:18):

VM_195_29_sles10_64:~/tmp> g++ –version g++ (GCC) 4.1.2 20070115 (prerelease) (SUSE Linux)

VM_195_29_sles10_64:~/tmp> g++ bind.cpp bind.cpp: In member function ‘void (* Foo::mybind())(void*, int, int)’: bind.cpp:15: error: converting from ‘void (Foo::)(int, int)’ to ‘void ()(void*, int, int)’ 最后的那段代码编译错误

ZRJ (2014-04-30 19:27:33):

确实，看来我之前是编译器老旧侥幸通过，不过 Foo::add 这个函数的参数列表确实是 (void*, int, int) 的，怎么把这个函数的指针弄出来是个问题

对引用取地址

Sat, 29 Mar 2014 18:00:48 +0800

今天突然想到，如果我们对一个引用取地址，那么会怎么样呢，例如这样

#include <stdio.h>

class CNumber {
public:
	int n;
};

void printByPointer(CNumber* pNumber) {
	printf("%d\n", pNumber->n);
}

void printByRef(CNumber& oNumber) {
	printf("%d\n", oNumber.n);
}

void passPointer(CNumber& oNumber) {
	printByPointer(&oNumber);
}

int main() {
	CNumber oNumber;
	oNumber.n = 5;
	printByPointer(&oNumber);
	printByRef(oNumber);
	passPointer(oNumber);
	return 0;
}

显然前面两个都可以正常运行，那么第三个呢，实测下来，也是可以的，也就是说，对一个引用取地址，可以得到正确的地址

gcc 链接时动态库和静态库的优先选择

Fri, 14 Mar 2014 20:10:56 +0800

老话题了，不过还是记一笔

先看文件

ModuleA.cpp

int add(int a, int b)
{
    return a + b;
}

ModuleB.cpp

int minus(int a, int b)
{
    return a - b;
}

Main.cpp

#include <stdio.h>

int add(int, int);
int minus(int , int);

int main()
{
    printf("%d\n", add(1, 2));
    printf("%d\n", minus(2, 1));
    return 0;
}

Makefile

all:
	g++ -c -fPIC Main.cpp
	g++ -c -fPIC ModuleA.cpp
	g++ -c -fPIC ModuleB.cpp
	g++ -shared ModuleA.o ModuleB.o -o libmodule.so
	g++ -o Run Main.o -L./ -lmodule
clean:
	rm *.o *.so Run

记得指定动态库路径

$ export LD_LIBRARY_PATH=./:$LD_LIBRARY_PATH

ldd 确认一下

$ ldd Run 
/$LIB/libonion.so => /lib64/libonion.so (0x00002b98dea29000)
libmodule.so => ./libmodule.so (0x00002b98deb39000)
libstdc++.so.6 => /usr/lib64/libstdc++.so.6 (0x00002b98dec4d000)
libm.so.6 => /lib64/libm.so.6 (0x00002b98dee4c000)
libgcc_s.so.1 => /lib64/libgcc_s.so.1 (0x00002b98defa1000)
libc.so.6 => /lib64/libc.so.6 (0x00002b98df0ae000)
libdl.so.2 => /lib64/libdl.so.2 (0x00002b98df2ef000)
/lib64/ld-linux-x86-64.so.2 (0x00002b98de90d000)

跑起来

$ ./Run 
3
1

再来看静态的方式，修改后的 Makefile

all:
	g++ -c -fPIC Main.cpp
	g++ -c -fPIC ModuleA.cpp
	g++ -c -fPIC ModuleB.cpp
	ar -r libmodule.a ModuleA.o ModuleB.o
	g++ -o Run Main.o -L./ -lmodule
clean:
	rm *.o *.a Run

编译出来的已经不依赖动态库了（废话）

$ ldd Run 
/$LIB/libonion.so => /lib64/libonion.so (0x00002ad9ce948000)
libstdc++.so.6 => /usr/lib64/libstdc++.so.6 (0x00002ad9cea58000)
libm.so.6 => /lib64/libm.so.6 (0x00002ad9cec56000)
libgcc_s.so.1 => /lib64/libgcc_s.so.1 (0x00002ad9cedac000)
libc.so.6 => /lib64/libc.so.6 (0x00002ad9ceeb9000)
libdl.so.2 => /lib64/libdl.so.2 (0x00002ad9cf0f9000)
/lib64/ld-linux-x86-64.so.2 (0x00002ad9ce82c000)

静态版本的 Run 是 9850 字节，动态是 9954 字节，这。。

下面问题来了，如果静态动态都有，链接器要哪个呢

all:
	g++ -c -fPIC Main.cpp
	g++ -c -fPIC ModuleA.cpp
	g++ -c -fPIC ModuleB.cpp
	ar -r libmodule.a ModuleA.o ModuleB.o
	g++ -shared ModuleA.o ModuleB.o -o libmodule.so
	g++ -o Run Main.o -L./ -lmodule
clean:
	rm *.o *.a *.so Run

答案是动态库

$ ldd Run 
/$LIB/libonion.so => /lib64/libonion.so (0x00002b2243070000)
libmodule.so => ./libmodule.so (0x00002b2243180000)
libstdc++.so.6 => /usr/lib64/libstdc++.so.6 (0x00002b2243294000)
libm.so.6 => /lib64/libm.so.6 (0x00002b2243493000)
libgcc_s.so.1 => /lib64/libgcc_s.so.1 (0x00002b22435e8000)
libc.so.6 => /lib64/libc.so.6 (0x00002b22436f5000)
libdl.so.2 => /lib64/libdl.so.2 (0x00002b2243936000)
/lib64/ld-linux-x86-64.so.2 (0x00002b2242f54000)

可以这样来强制链接静态库

all:
	g++ -c -fPIC Main.cpp
	g++ -c -fPIC ModuleA.cpp
	g++ -c -fPIC ModuleB.cpp
	ar -r libmodule.a ModuleA.o ModuleB.o
	g++ -shared ModuleA.o ModuleB.o -o libmodule.so
	g++ -o Run Main.o libmodule.a
clean:
	rm *.o *.a *.so Run

历史评论

Joanie Lucien (2018-06-07 20:57:09):

Nice bro!

tr1 memory 中的智能指针

Tue, 11 Mar 2014 09:34:04 +0800

tr1/memory 中带了一个 shared_ptr 的智能指针，也有配套的 weak_ptr，但是没有 scoped_ptr，不过起码可以不用等到 c++11 的编译器了

#include <tr1/memory>
#include <stdio.h>

class CTest {
    public:
        CTest() {
            printf("CTest\n");
        }
        ~CTest() {
            printf("~CTest\n");
        }
};

std::tr1::shared_ptr<CTest> GetSharedTest() {
    printf("in get\n");
    std::tr1::shared_ptr<CTest> pTest(new CTest());
    printf("leaving get\n");
    return pTest;
}


int main() {
    std::tr1::shared_ptr<CTest> pTest = GetSharedTest();
    return 0;
}

输出

in get
CTest
leaving get
~CTest

-—————————————

2014-3-17 11:11:26 update 常说要 RAII，来看看文件操作如何 RAII

#include <stdio.h>
#include <string>
#include <assert.h>
#include <tr1/memory>

class CFile {
public:
    FILE* fp;
    CFile(const char* pPathToFile, const char* pMod) {
        printf("opening %s with mod %s\n", pPathToFile, pMod);
        fp = fopen(pPathToFile, pMod);
    }
    ~CFile() {
        if (fp) {
            printf("closing file\n");
            fclose(fp);
        }
    }
private:
    CFile(CFile const &);
    CFile& operator=(CFile const &);
};
typedef std::tr1::shared_ptr<CFile> FileSharedPtr;

int main() {
    FileSharedPtr pFile(new CFile("test.txt", "w"));
    assert(pFile->fp != NULL);
    std::string strGreeting("hello");
    fwrite(strGreeting.c_str(), strGreeting.length(), 1, pFile->fp);
    return 0;
}

最简 Makefile

Thu, 06 Mar 2014 12:13:34 +0800

依赖于 Makefile 的自动推导，可以写出非常简化的 Makefile，假设目录下有有 Number.cpp 的单个 cpp 文件，内含 main 函数，那么，Makefile 可以这样写

all: Number

是的，就一行，all 作为默认 target，Number 作为依赖，自动推导出依赖源文件 Number.c*，如果是 cpp，得到编译器 g++，如果是 c，得打编译器 cc，然后 make 一下，可以得到下面的输出

$ make
g++     Number.cpp   -o Number

历史评论

wanax (2014-03-19 16:46:46):

我就想试试那个头像是怎么出来的…

wanax (2014-03-19 16:49:02):

soga

ZRJ (2014-06-24 18:16:56):

makefile 内置的变量名是 CXXFLAGS

修改网卡缓冲以提高吞吐量

Fri, 28 Feb 2014 16:36:55 +0800

在单机并发上万的时候，发现 sendto 函数比较容易出现返回错误 EAGAIN，对应的错误消息为 Resource temporarily unavailable，这种情况下认为是应用层写入过快，导致网卡缓冲满了

使用这个命令来查看缓冲区现有大小

# ethtool -g eth1
Ring parameters for eth1:
Pre-set maximums:
RX:		4096
RX Mini:	0
RX Jumbo:	0
TX:		4096
Current hardware settings:
RX:		256
RX Mini:	0
RX Jumbo:	0
TX:		256

使用这个命令来修改缓冲区大小

# ethtool -G eth1 rx 2048
# ethtool -G eth1 tx 2048

修改之后再查看一下

# ethtool -g eth1
Ring parameters for eth1:
Pre-set maximums:
RX:		4096
RX Mini:	0
RX Jumbo:	0
TX:		4096
Current hardware settings:
RX:		2048
RX Mini:	0
RX Jumbo:	0
TX:		2048

但是发现这样修改之后，没有起作用，sendto 函数的失败率还是很高，继续看，发现 socket 族函数本身有一个 setsockopt 的函数，在代码里面可以设置，写法如下

int iOriginalSendBufferSize = 0;
socklen_t iIntLen = sizeof(int);
getsockopt(iSocket, SOL_SOCKET, SO_SNDBUF, &iOriginalSendBufferSize, &iIntLen);
LOG_INFO("before set, send buffer is %d", iOriginalSendBufferSize);

int nSendBuf=32*1024;
setsockopt(iSocket,SOL_SOCKET,SO_SNDBUF,(const  char*)&nSendBuf,sizeof(int));  

int iFinalSendBufferSize = 0;
getsockopt(iSocket, SOL_SOCKET, SO_SNDBUF, &iFinalSendBufferSize, &iIntLen);
LOG_INFO("after set, send buffer is %d", iFinalSendBufferSize);

这里可能会觉得多此一举，设完还要看，有啥好看的，但是，看输出

before set, send buffer is 8388608
after set, send buffer is 65536

神奇吧，设的明明是 32k，出来居然 64k 了，买一送一啊这是

查资料看到这里，http://blog.csdn.net/c359719435/article/details/8815499

Author：阿冬哥

Created：2013-4-17

Blog：http://blog.csdn.net/c359719435/

Copyright 2013 阿冬哥 http://blog.csdn.net/c359719435/

使用以及转载请注明出处

1 设置socket tcp缓冲区大小的疑惑疑惑1：通过setsockopt设置SO_SNDBUF、SO_RCVBUF这连个默认缓冲区的值，再用getsockopt获取设置的值，发现返回值是设置值的两倍。为什么？通过网上查找，看到linux的内核代码/usr/src/linux-2.6.13.2/net/core/sock.c，找到sock_setsockopt这个函数的这段代码：

case SO_SNDBUF: /* Don’t error on this BSD doesn’t and if you think about it this is right. Otherwise apps have to play ‘guess the biggest size’ games. RCVBUF/SNDBUF are treated in BSD as hints */ if (val > sysctl_wmem_max)//val是我们想设置的缓冲区大小的值 val = sysctl_wmem_max;//大于最大值，则val值设置成最大值 sk->sk_userlocks |= SOCK_SNDBUF_LOCK; if ((val * 2) < SOCK_MIN_SNDBUF)//val的两倍小于最小值，则设置成最小值 sk->sk_sndbuf = SOCK_MIN_SNDBUF; else sk->sk_sndbuf = val * 2;//val的两倍大于最小值，则设置成val值的两倍 /* * Wake up sending tasks if we * upped the value. */ sk->sk_write_space(sk); break; case SO_RCVBUF: /* Don’t error on this BSD doesn’t and if you think about it this is right. Otherwise apps have to play ‘guess the biggest size’ games. RCVBUF/SNDBUF are treated in BSD as hints */ if (val > sysctl_rmem_max) val = sysctl_rmem_max; sk->sk_userlocks |= SOCK_RCVBUF_LOCK; /* FIXME: is this lower bound the right one? */ if ((val * 2) < SOCK_MIN_RCVBUF) sk->sk_rcvbuf = SOCK_MIN_RCVBUF; else sk->sk_rcvbuf = val * 2; break; 从上述代码可以看出：（1）当设置的值val > 最大值sysctl_wmem_max，则设置为最大值的2倍：2*sysctl_wmem_max；（2）当设置的值的两倍val*2 > 最小值，则设置成最小值：SOCK_MIN_SNDBUF；（3）当设置的值val < 最大值sysctl_wmem_max，且 val*2 > SOCK_MIN_SNDBUF，则设置成2*val。

查看linux 手册： SO_RCVBUF： Sets or gets the maximum socket receive buffer in bytes. The kernel doubles this value (to allow space for bookkeeping overhead) when it is set using setsockopt(2), and this doubled value is returned by getsockopt(2). The default value is set by the /proc/sys/net/core/rmem_default file, and the maximum allowed value is set by the /proc/sys/net/core/rmem_max file. The minimum (doubled) value for this option is 256. 查看我的主机Linux 2.6.6 ：/proc/sys/net/core/rmem_max： 4194304 //4M 查看/proc/sys/net/core/wmem_max： 8388608 //8M 所以，能设置的接收缓冲区的最大值是8M，发送缓冲区的最大值是16M。

疑惑2：为什么要有2倍这样的一个内核设置呢？我的理解是，用户在设置这个值的时候，可能只考虑到数据的大小，没有考虑数据封包的字节开销。所以将这个值设置成两倍。

注：overhead，在计算机网络的帧结构中，除了有用数据以外，还有很多控制信息，这些控制信息用来保证通信的完成。这些控制信息被称作系统开销。 2 tcp缓冲区大小的默认值建立一个socket，通过getsockopt获取缓冲区的值如下：发送缓冲区大小：SNDBufSize = 16384 接收缓冲区大小：RCVBufSize = 87380

疑惑3：linux手册中，接收缓冲区的默认值保存在/proc/sys/net/core/rmem_default，发送缓冲区保存在/proc/sys/net/core/wmem_default。 [root@cfs_netstorage core]# cat /proc/sys/net/core/rmem_default 1048576 [root@cfs_netstorage core]# cat /proc/sys/net/core/wmem_default 512488

可知，接收缓冲区的默认值是：1048576，1M。发送缓冲区的默认值是：512488，512K。为什么建立一个socket时得到的默认值是87380、16384？？？

进一步查阅资料发现， linux下socket缓冲区大小的默认值在/proc虚拟文件系统中有配置。分别在一下两个文件中： /proc/sys/net/ipv4/tcp_wmem [root@cfs_netstorage core]# cat /proc/sys/net/ipv4/tcp_wmem 4096 16384 131072 //第一个表示最小值，第二个表示默认值，第三个表示最大值。 /proc/sys/net/ipv4/tcp_rmem [root@cfs_netstorage core]# cat /proc/sys/net/ipv4/tcp_rmem 4096 87380 174760

由此可见，新建socket，选取的默认值都是从这两个文件中读取的。可以通过更改这两个文件中的值进行调优，但是最可靠的方法还是在程序中调用setsockopt进行设置。通过setsockopt的设置，能设置的接收缓冲区的最大值是8M，发送缓冲区的最大值是16M（Linux 2.6.6中）。

原来还真的是买一送一

于是在这个地方，把 SNDBUF 这个选项改成 8m 或者更大，sendto 的错误就没有了

-——————–

2014-2-28 17:31:44 update 原来对于 tcp 和 udp，这个缓冲区默认大小还不不一样

#include <stdio.h>
#include <assert.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <string.h>
#include <unistd.h>
int tcpSrv(short iListenPort)
{
    int iListenFd = socket(AF_INET, SOCK_STREAM, 0);
    assert(iListenFd > 0);
    
    int iOriginalSendBufferSize = 0;
    socklen_t iIntLen = sizeof(iOriginalSendBufferSize);
    getsockopt(iListenFd, SOL_SOCKET, SO_SNDBUF, &iOriginalSendBufferSize, &iIntLen);
    printf("default send buffer size %d\n", iOriginalSendBufferSize);
    
    struct sockaddr_in stServerAddr;
    stServerAddr.sin_family = AF_INET;
    stServerAddr.sin_addr.s_addr = htonl(INADDR_ANY);
    stServerAddr.sin_port = htons(iListenPort);
    assert(bind(iListenFd, (struct sockaddr*)&stServerAddr, sizeof(stServerAddr)) == 0);
    assert(listen(iListenFd, 1024) == 0);
    printf("listening...\n");
    while (1) {
        int iAcceptFd = accept(iListenFd, (struct sockaddr*)NULL, NULL);
        assert(iAcceptFd > 0);
        char* pStrResponse = "HTTP/1.1 200 OK\r\nConnection: close\r\n\r\n";
        int iResponseLen = strlen(pStrResponse);
        int iSendByte = send(iAcceptFd, pStrResponse, iResponseLen, 0);
        assert(iSendByte == iResponseLen);
        close(iAcceptFd);
    }
    close(iListenFd);
    return 0;
}


int udpSrv(short iListenPort)
{
    int iListenFd = socket(AF_INET, SOCK_DGRAM, 0);
    assert(iListenFd > 0);
    
    int iOriginalSendBufferSize = 0;
    socklen_t iIntLen = sizeof(iOriginalSendBufferSize);
    getsockopt(iListenFd, SOL_SOCKET, SO_SNDBUF, &iOriginalSendBufferSize, &iIntLen);
    printf("default send buffer size %d\n", iOriginalSendBufferSize);
    
    struct sockaddr_in stServerAddr;
    stServerAddr.sin_family = AF_INET;
    stServerAddr.sin_addr.s_addr = htonl(INADDR_ANY);
    stServerAddr.sin_port = htons(iListenPort);
    assert(bind(iListenFd, (struct sockaddr*)&stServerAddr, sizeof(stServerAddr)) == 0);
    printf("listening...\n");
    while (1) {
        char buffer[BUFSIZ] = {0};
        struct sockaddr_in stClientAddr;
        socklen_t stClientAddrLen = sizeof(stClientAddr);
        int iReceivedLen = recvfrom(iListenFd, buffer, sizeof(buffer), 0, (struct sockaddr*)&stClientAddr, &stClientAddrLen);
        int iSendByte = sendto(iListenFd, &buffer, iReceivedLen, 0, (struct sockaddr*)&stClientAddr, stClientAddrLen);
    }
    close(iListenFd);
    return 0;
}


int main()
{
    udpSrv(8000);
    return 0;
}

tcp 的

default send buffer size 16384
listening...

udp 的

default send buffer size 8388608
listening...

历史评论

wanax (2014-03-19 16:43:48):

PDU与SDU的考虑吧，猜的…

ZRJ (2014-03-19 20:12:50):

我能说我看了你回复才知道这两个名词吗。。。

手工编译 apache 的一些琐碎

Tue, 25 Feb 2014 16:46:16 +0800

压测的时候用到 apache ab，但是 ab 本身支持的并发最大 1000，过了报错，修改源码 support/ab.c 把这行注释掉

apr_err("apr_socket_recv", status);

但是编译的时候各种依赖，手工解决好烦，首先出来 undefined reference to apr 系列的函数，查到这里，http://hi.baidu.com/yang171892549/item/2da5f0137e6cbecf39cb303f，说了

collect2: ld returned 1 exit status make[1]: *** [httpd] Error 1 make[1]: Leaving directory `/tmp/httpd-2.2.22’ make: *** [all-recursive] Error 1 的错误，解决方案：搜了下解决方案说：编译apache之前应该先安装apr和apr-util，rpm -qa看了一下都是有的，但是还是报错。原来编译的时候 ./configure –prefix=/usr/local/httpd –enable-mods-shared=most –with-included-apr

但是使用 with-included-apr 又报错，configure: error: Bundled APR requested but not found at ./srclib/. Download and unpack the corresponding apr and apr-util packages to ./srclib/.，查到这里，http://coolwa.blog.51cto.com/1512988/851457

执行配置安装httpd时出错 configure: error: Bundled APR requested but not found at ./srclib/. Download and unpack the corresponding apr and apr-util packages to ./srclib/. 需要下载apr和apr-utils 并解压到./srclib/, 再进行编译 #wget http://apache.etoak.com//apr/apr-util-1.4.1.tar.gz #wget http://apache.etoak.com//apr/apr-1.4.6.tar.gz #tar zxvf apr-1.4.6.tar.gz #tar zxvf apr-utli-1.4.1.tar.gz #cp -rf apr-1.4.6 httpd-2.4.1/srclib/apr #cp -rf apr-util-1.4.6 httpd-2.4.1/srclib/apr-util

终于编译起来，其他一些琐碎的依赖，不一一细表。

历史评论

ZRJ (2014-02-27 20:45:05):

坑爹啊，压测的时候发现并发过 1000 就会出问题，一直想想不通，代码反复查，后来才发现，是跑服务进程的 ulimit -n 没改，默认估计是 1024，结果新的 fd 一直进不来，真是坑爹啊

分支预测以及 gcc 的 __builtin_expect

Mon, 10 Feb 2014 16:26:42 +0800

在阅读代码的时候，发现有类似这种写法：

bvl = bvec_alloc(gfp_mask, nr_iovecs, &idx);
if (unlikely(!bvl)) {
  mempool_free(bio, bio_pool);
  bio = NULL;
  goto out;
}

注意到第二行，if 的判断中，加入了一个 unlikely，这个东西是一个 CPU 指令的优化，用于分支预判，关于分支预判，可以看这个 stackoverflow 的经典问答，http://stackoverflow.com/questions/11227809/why-is-processing-a-sorted-array-faster-than-an-unsorted-array，简单的说，就是 CPU 由于指令流水，需要在上一个条件判断的指令尚未得到结果的时候，从代码段中预读下一个指令，这个时候，会使用一个分支预测的东西，猜一个分支，然后把指令先读出来

举例说明：假如我们有如下的代码：

if (do_judge())
{
    func_a();
}
else
{
    func_b();
}

CPU 一边读取指令，一边执行指令，同时进行，那么当指令的执行模块在跑 do_judge() 这个判断的时候，读取的模块怎么办呢，一种方法是停下来，等 do_judge() 跑完，知道结果了，再根据 true or false 去读取对应分支下面的代码指令，但是这样就要干等，会浪费好几个 CPU 时钟周期，另外一种方式，就是猜，我先猜一个结果，反正不是 true 就是 false 嘛，猜一个然后先把对应的指令读出来，准备好给执行模块用。显然，如果猜中了，那么皆大欢喜，CPU 可以继续高速运转，如果不幸猜错了，那么就悲剧了，需要刚刚的这几步全部退回去重来，重新去读取另外一个分支下面的代码。自然效率就会大打折扣了。

回到之前的 likely，这个东西其实是一个宏定义，定义如下

#define likely(x)       __builtin_expect(!!(x), 1)
#define unlikely(x)     __builtin_expect(!!(x), 0)

__builtin_expect 是一个 gcc 的内置函数，那么这个写法的用意就很好理解了，程序员根据经验，显式的指明当前 if 分支一般情况下是否会成立，好加大 CPU 分支预测的成功率，加快代码的执行效率，不过，另外我们注意到，定义中有这个写法

!!(x)

这种两次取反的写法，作用是把非零的值，全部转到 1 上面去，也就说 0 两次取反后还是 0，而其他的非零值，包括大于 1 的整形，布尔型，等等，都会转成 1，好跟 __builtin_expect 后面的第二个参数比较。更多资料，可以进一步阅读，http://kernelnewbies.org/FAQ/LikelyUnlikely，http://stackoverflow.com/questions/2527086/what-does-x-mean-in-c-esp-the-linux-kernel

函数返回对象时的问题

Fri, 24 Jan 2014 18:58:20 +0800

来看这个代码

#include <iostream>
#include <string>
#include <map>

std::map<std::string, std::string> mapHttpRequest;

std::string GetString(std::string strKey)
{
    std::map<std::string, std::string>::iterator it = mapHttpRequest.find(strKey);
    if (it != mapHttpRequest.end())
    {
        return it->second;
    }    
    return "";
}

int SplitString()
{
    std::string strUrlParamValue = GetString("l");
    std::cout<<"before: "<<strUrlParamValue<<std::endl;
    char *pInOuter;
    char* p = strtok(const_cast<char*>(strUrlParamValue.c_str()), "|_");
    while (p)
    {
        std::cout<<"-> "<<p<<std::endl;
        p = strtok(NULL, "|_");
    }
    std::cout<<"after: "<<strUrlParamValue<<std::endl;
    return 0;
}

int main()
{
    mapHttpRequest["l"] = "4001|4002";
    SplitString();
    SplitString();
    return 0;
}

一般理解，连续调用两次 split string 函数，输出应该是完全一致的吧，嗯，来看结果

before: 4001|4002
-> 4001
-> 4002
after: 40014002
before: 40014002
-> 4001
after: 40014002

环境是 linux 2.6.16 64bit，gcc 的版本是 4.1.2

不过，在 vs 2005 下跑这个代码，得到的输出确实这样的

before: 4001|4002
-> 4001
-> 4002
after: 4001 4002
before: 4001|4002
-> 4001
-> 4002
after: 4001 4002

嗯，这个跟想象中的差不多吧

把细节打出来看看呗

#include <iostream>
#include <string>
#include <map>

std::map<std::string, std::string> mapHttpRequest;

std::string GetString(std::string strKey)
{
    std::map<std::string, std::string>::iterator it = mapHttpRequest.find(strKey);
    if (it != mapHttpRequest.end())
    {
        std::cout<<"map value addr: "<<(void*)it->second.c_str()<<std::endl;
        return it->second;
    }    
    return "";
}

int SplitString()
{
    std::string strUrlParamValue = GetString("l");
    std::cout<<"get string func return addr: "<<(void*)strUrlParamValue.c_str()<<std::endl;
    std::cout<<"before: "<<strUrlParamValue<<std::endl;
    char *pInOuter;
    char* p = strtok(const_cast<char*>(strUrlParamValue.c_str()), "|_");
    while (p)
    {
        std::cout<<(void*)p<<" -> "<<p<<std::endl;
        p = strtok(NULL, "|_");
    }
    std::cout<<"after: "<<strUrlParamValue<<std::endl;
    return 0;
}

int main()
{
    mapHttpRequest["l"] = "4001|4002";
    SplitString();
    SplitString();
    return 0;
}

先看 linux 下的结果

map value addr: 0x504098
get string func return addr: 0x504098
before: 4001|4002
0x504098 -> 4001
0x50409d -> 4002
after: 40014002
map value addr: 0x504098
get string func return addr: 0x504098
before: 40014002
0x504098 -> 4001
after: 40014002

再看 vs 2005 的执行结果

map value addr: 005D345C
get string func return addr: 0018FDF8
before: 4001|4002
0018FDF8 -> 4001
0018FDFD -> 4002
after: 4001 4002
map value addr: 005D345C
get string func return addr: 0018FDF8
before: 4001|4002
0018FDF8 -> 4001
0018FDFD -> 4002
after: 4001 4002

其中的原因，有可能是编译器的返回值优化，也有可能是 stl 的各自实现不同，现在过年了，没心情细究啊。。

gcc 编译时动态静态库的问题

Tue, 14 Jan 2014 10:08:41 +0800

一般来说，动态静态库的问题，可以参考这个文章，http://blog.csdn.net/ast_224/article/details/3988244

gcc生成静态库和动态库

一、库文件简介

简单地说，库（Library）就是一组已经写好了的函数和变量、经过编译代码，是为了能够提高开发效率和运行效率而设计的。库分为静态库（Static Library）和共享库（Shared library）两类。静态库文件的扩展名是.a，共享库文件的扩展名是.so（在CYGWIN环境下，分别叫做.o和.dll）。共享库现在常常被叫做动态库，是由于很多人借用了MS Windows的DLL（Dynamic Linked Library）这个词。（1）静态库静态是指每个用到该库的应用程序都拥有一份自己的库拷贝；应用程序运行的时候，即使将库删除也没有问题，因为应用程序自己已经有了自己的拷贝。（2）共享库一个共享库有可能被多个所有应用程序共享。因此，对每个应用程序来说，即使不再使用某个共享库，也不应将其删除。此外，应用程序需要正确的环境变量设置（LD_LIBRARY_PATH），从而找到共享库所在的位置，否则，应用程序运行时会报告找不到这个库。

二、关于使用库的问题

如果库是已经编译好的，那么如何在开发、运行应用程序时使用呢？头文件和库文件所在的路径，必须通过适当的方式通知给编译器、链接器和相关的应用程序。对于静态库来说，主要涉及开发工具，如gcc。例如，用gcc编译、链接时，需要通过适当的路径找到头文件和静态库文件；实现的方法有两种： gcc的命令行参数（-I, -L） shell的环境变量（C_INCLUDE_PATH, LIBRARY_PATH 对于共享库来说，程序在运行时，如果用到了动态库，也需要找到对应的动态库文件；实现的方法： shell的环境变量（LD_LIBRARY_PATH） 1） gcc命令行参数（-I, -L）默认情况下，gcc会自动搜索下面的路径：对头文件： /usr/local/include/ /usr/include/ 对库文件： /usr/local/lib/ /usr/lib/ 但是由于系统管理员对系统安装路径有不同的配置，或者对于如64位系统等情况，上述路径对于一台具体的计算机来说可能不同。如果开发者还有自己工程所需的头文件和库文件，就要用gcc的-I和-L来指定对应的路径。如果需要链接库，还要用-l选项。例如：如果工程涉及到GDBM（GNU DataBase Management）包，需要libgdbm库，而系统中安装GDBM的路径是：头文件：/opt/gdbm-1.8.3/include 库文件：/opt/gdbm-1.8.3/lib/ 那么，gcc的命令参数是： $gcc … -I/opt/gdbm-1.8.3/include -L/opt/gdbm-1.8.3/lib –lgdbm 注意：为保证兼容性，必须坚决杜绝在C/C++源文件的#include语句中或者其他相关语句中使用上述路径。 2） shell环境变量（Environmental Variable）除了用命令行参数，还可以用环境变量来指示gcc搜索适当的路径。而由于Shell的不同，环境变量的设置方法也不同。常用的Shell有Bash, Csh和Tcsh。（1）Bash 对于Bash来说，除了由系统管理员配置的内容以外，每个用户的用户目录（$HOME）下，有个.bash_profile文件。可在该文件内，增加下面的两个语句来设置GDBM头文件路径的环境变量： C_INCLUDE_PATH=/opt/gdbm-1.8.3/include export C_INCLUDE_PATH 类似地，在该文件内用下面的两个语句来设置库文件路径的环境变量： LIBRARY_PATH=/opt/gdbm-1.8.3/lib export LIBRARY_PATH 在.bash_profile中有了上述语句以后，就不用再使用-I和-L来搜索特定包的路径了。但是链接库的时候，还是要用-l选项。 $gcc … –lgdbm 在Bash下，要检查有什么样的环境变量，可用env命令。 $env （2）Csh和Tcsh 如果是Csh或Tcsh，对环境变量的设置方法就不同了。在用户的（$HOME）目录下，相关的一些文件如下： .cshrc 每次进入Csh时的启动(Startup)文件 .tcshrc 每次进入Tcsh时的启动(Startup)文件（在Tcsh下，如果没有这个文件，系统会用.cshrc文件代替） .login 每次登录Shell时的启动(Startup)文件在Csh和Tcsh下，分为Shell变量和环境变量；前者是用来设置Shell本身的，而后者则是供其他程序使用的。一般习惯是：Shell变量在.cshrc中定义，而环境变量则在.login文件中定义。定义Shell变量的方法是在.cshrc或.tcshrc中用set语句： set history = 20 定义环境变量的方法是在.login文件中用setenv语句。对于上面关于GDBM的例子： setenv C_INCLUDE_PATH /opt/gdbm-1.8.3/include setenv LIBRARY_PATH /opt/gdbm-1.8.3/lib 在Csh和Tcsh下，可以用setenv命令来查看设置了哪些环境变量（如果要看Shell变量，要用set命令）。注意： - 设置Shell变量时要用“=”号； - 设置环境变量时，变量名与实际值（这里是真实路径）之间没有“=”号; - 不需要export。 3）使用共享库使用共享库的应用程序，要通过环境变量LD_LIBRARY_PATH找到对应的共享库文件。与其他环境变量一样，对LD_LIBRARY_PATH也要根据shell的种类和库文件的实际路径进行设置。但是，必须注意的是，与一般的环境变量不同，LD_LIBRARY_PATH的值，是已经安装了的所有共享库的路径，因此，在Bash下，不能简单地用下面的办法： LD_LIBRARY_PATH=/opt/gdbm-1.8.3/lib 错误！ export LD_LIBRARY_PATH 而必须用： LD_LIBRARY_PATH=/opt/gdbm-1.8.3/lib:$LD_LIBRARY_PATH export LD_LIBRARY_PATH 这样，就把其他共享库的路径也一起加入进来了。同样地，在Csh和Tcsh下， setenv LD_LIBRARY_PATH /opt/gdbm-1.8.3/lib:$LD_LIBRARY_PATH

三、关于库生成的问题我们通常把一些公用函数制作成函数库，供其它程序使用。函数库分为静态库和动态库两种。静态库在程序编译时会被连接到目标代码中，程序运行时将不再需要该静态库。动态库在程序编译时并不会被连接到目标代码中，而是在程序运行是才被载入，因此在程序运行时还需要动态库存在。

（1）静态库简单地说，静态库是一个目标文件的简单集合。因此，首先要解决目标文件。第一步：将各函数代码所在的源文件编译成目录文件。例如，对于myfunc.c, myproc.c gcc -c myfunc.c myproc.c 将得到myfunc.o和myproc.o。第二步：由ar（archive，归档的意思）把多个目标文件集合起来。 $ar -r libmyjob.a myfunc.o myproc.o 通常，静态库的命名方式应遵守libXXXXX.a格式。应用程序在使用静态库的时候，通常只需要把命名中的XXXXX部分传递给gcc即可。例如： $gcc –o mywork –lmyjob … 意为让gcc（实际上是gcc调用ld）去连接一个名字为libmyjob.a（或者libmyjob.so）的库。如果库的命名不遵循libXXXXX.a的格式就找不到相应文件。例子：创建静态库 hello.h为该函数库的头文件。hello.c是函数库的源程序，其中包含公用函数hello，该函数将在屏幕上输出" hello XXX!"。main.c为测试库文件的主程序，在主程序中调用了公用函数hello。程序1： //hello.h #ifndef HELLO_H #define HELLO_H void hello(const char *name); #endif 程序2： //hello.c #include void hello(const char *name) { printf(“hello %s! /n”,name); } 程序3： //main.c #include “hello.h” int main() { hello(“everyone”); return 0; }

实现步骤：第一步：必须将源程序hello.c通过gcc先编译成.o文件，生成hello.o（静态库/动态库，都是由.o文件创建的）；第二步：由.o文件创建静态库,生成libmyhello.a（静态库文件名的命名规范是以lib为前缀，紧接着跟静态库名，扩展名为.a）创建静态库用ar命令；第三步：在程序中使用静态库；（只需要在使用到这些公用函数的源程序中包含这些公用函数的原型声明，然后在用gcc命令生成目标文件时指明静态库名，gcc将会从静态库中将公用函数连接到目标文件中。注意，gcc会在静态库名前加上前缀lib，然后追加扩展名.a得到的静态库文件名来查找静态库文件）第四步：删除静态库文件，程序照常运行，静态库中的公用函数hello已经连接到目标文件main中了。运行： [root@localhost moduletest]# ls hello.c hello.h main.c [root@localhost moduletest]# gcc -c hello.c [root@localhost moduletest]# ls hello.c hello.h hello.o main.c [root@localhost moduletest]# ar crv libmyhello.a hello.o a - hello.o [root@localhost moduletest]# ls hello.c hello.h hello.o libmyhello.a main.c [root@localhost moduletest]# gcc main.c libmyhello.a -o main [root@localhost moduletest]# ./main hello everyone! [root@localhost moduletest]# rm -f libmyhello.a [root@localhost moduletest]# ls hello.c hello.h hello.o main main.c [root@localhost moduletest]# ./main hello everyone! [root@localhost moduletest]#

（2）共享库共享库的构造复杂一些，通常是一个ELF格式的文件。可以有三种方法生成： $ld -G $gcc -shared $libtool 用ld最复杂，用gcc -share就简单的多，但是-share并非在任何平台都可以使用。GNU提供了一个更好的工具libtool，专门用来在各种平台上生成各种库。用gcc的-shared参数： gcc –shared –o libmyjob.so myjob.o 这样，就通过myjob.o生成了共享库文件libmyjob.so。特别地，在CYGWIN环境下，仍需要输出符合Windows命名的共享库（动态库），即libXXXXX.dll。如： gcc –shared –o libmyjob.dll myjob.o

例子：创建动态库（延用上面的程序1，2，3）实现步骤：第五步：由.o文件创建动态库文件（命令：gcc -shared -fPCI -o libmyhello.so hello.o）；第六步：在程序中使用动态库；（在程序中使用动态库和使用静态库完全一样，也是在使用到这些公用函数的源程序中包含这些公用函数的原型声明，然后在用gcc命令生成目标文件时指明动态库名进行编译。程序在运行时，会在/usr/lib和/lib等目录中查找需要的动态库文件。若找到，则载入动态库，否则将提示错误信息而终止程序运行。要将文件libmyhello.so复制到目录/usr/lib中）运行： [root@localhost moduletest]# ls hello.c hello.h hello.o main.c [root@localhost moduletest]# gcc -shared -fPIC -o libmyhello.so hello.o [root@localhost moduletest]# ls hello.c hello.h hello.o libmyhello.so main.c [root@localhost moduletest]# gcc main.c libmyhello.so -o main [root@localhost moduletest]# ls hello.c hello.h hello.o libmyhello.so main main.c [root@localhost moduletest]# ./main ./main: error while loading shared libraries: libmyhello.so: cannot open shared object file: No such file or directory [root@localhost moduletest]# mv libmyhello.so /usr/lib 可以： [root@localhost moduletest]# ls hello.c hello.h hello.o main main.c [root@localhost moduletest]# ./main hello everyone! [root@localhost moduletest]# 或者： [root@localhost moduletest]# rm -f main [root@localhost moduletest]# ls hello.c hello.h hello.o main.c [root@localhost moduletest]# gcc -Wall -g main.c -lmyhello -o main [root@localhost moduletest]# ls hello.c hello.h hello.o main main.c [root@localhost moduletest]# ./main hello everyone! [root@localhost moduletest]# 注意：当静态库和动态库同名时， gcc命令将优先使用动态库。

（3）库生成以后的配置如果要把自己开发的库文件安装到操作系统中，需要有管理员权限： (a) 把库文件复制到适当的目录：可以把自己开发的动态连接库放到/usr/local/lib（或者/usr/lib），或放到其他目录，但不论放在那里，都必须与LIBRARY_PATH的值、LD_LIBRARY_PATH的值相一致。 (b) 修改相关的系统配置文件：修改/etc/ld.so.conf，然后利用/sbin/ldconfig来完成。

Note: 编译参数解析最主要的是GCC命令行的一个选项: -shared 该选项指定生成动态连接库（让连接器生成T类型的导出符号表，有时候也生成弱连接W类型的导出符号），不用该标志外部程序无法连接。相当于一个可执行文件 l -fPIC：表示编译为位置独立的代码，不用此选项的话编译后的代码是位置相关的所以动态载入时是通过代码拷贝的方式来满足不同进程的需要，而不能达到真正代码段共享的目的。 l -L.：表示要连接的库在当前目录中 l -ltest：编译器查找动态连接库时有隐含的命名规则，即在给出的名字前面加上lib，后面加上.so来确定库的名称 l LD_LIBRARY_PATH：这个环境变量指示动态连接器可以装载动态库的路径。 l 当然如果有root权限的话，可以修改/etc/ld.so.conf文件，然后调用 /sbin/ldconfig来达到同样的目的，不过如果没有root权限，那么只能采用输出LD_LIBRARY_PATH的方法了。调用动态库的时候有几个问题会经常碰到，有时，明明已经将库的头文件所在目录通过 “-I” include进来了，库所在文件通过 “-L”参数引导，并指定了“-l”的库名，但通过ldd命令察看时，就是死活找不到你指定链接的so文件，这时你要作的就是通过修改 LD_LIBRARY_PATH或者/etc/ld.so.conf文件来指定动态库的目录。通常这样做就可以解决库无法链接的问题了。

但是，奇葩的事情总是有的，我们现在面临的问题是，主程序是一个框架类型的可执行，这个框架跑起来之后，会用 dlopen 的方式，打开一个 so，业务逻辑在这个 so 里面，那么，自然的，这个 so 就是要用动态的方式来编译了，但是，这个 so 又依赖于 google pb，在部署的时候，环境并不保证有 pb，或者 pb 的版本并不保证匹配，那么，我们希望，把这个 pb 的库，静态的链接进来，也就是这个文章说道的，http://www.cnblogs.com/nobugtodebug/archive/2012/11/07/e6cd72c67b3dd843f40d7ce919f7336a.html

动态库(.so)链接静态库(.a)的情况总结一般来说在链接时想要使用静态库有三种方法： 1、link时加上 -static 选项；当加上 -static选项后，gcc会把所有用到的库都做静态连接。 2、link时直接指定想要静态连接的.a文件的绝对路径。优点是除非.a文件不存在，否则肯定有效；缺点也是很明显，拿到其他机器上编译时，.a文件也必须在相同的路径下存放。 3、在要静态连接的库前指定-Bstatic ，在要动态连接的库前指定-Bdynamic选项。连接器在看到-Bstatic时会优于去找静态库，如果找不到再去找动态库。 -Bdynamic也是同样的情况。（可是我实验的结果是这两个选项根本不起作用，我的环境是centos 6.2 gcc4.7.2, 仔细看了gcc 文档，这两个选项是针对VxWorks平台的，所以不起作用。）当我们要编译一个so提供给外部使用，这个so本身依赖一些第三方库。但是我们却希望so的使用者不用关心该so对其他库的依赖。很自然的是会想到在编译so的时候把依赖到的第三方库静态链接进来。我在这样做的时候碰到了问题：指定-static选项时，link失败，错误提示说要用到的object文件应该用-fPIC选项重新编译才行（也就是说，只有用-fPIC选项编译的object文件能被link到.so里）；当直接给出.a的绝对路径的时候link成功，但是.so里却并没有直正包含所用到的符合连接。针对碰到的问题，我做了一些实验。实验如下： static.c

#include const char* sz_static = “i’m a static str.”; void print_niuzai_said() { printf(“in static lib, niu zai said, i’m happy!\n”); } dynamic.c #include #include “static.h” void print_papa_said() { print_niuzai_said(); printf(“in dynamic lib, papa said, niu zai is wonderful!\n”); } main.c #include #include “dynamic.h” int main(int argc, char** argv) { print_papa_said(); return 0; } 分别用两组命令编译出了两个.a 文件 1、gcc -o static.o -c static.c ar -r libstatic.a static.o 2、gcc -o static_shared.o -shared -fPIC -c static.c ar -r libstatic_shared.a static_shared.o 然后用此命令 “gcc -o dynamic.o -c dynamic.c” 编译出dynamic.o文件接下来就是本文的主题了，链接生成libdynamic.so.此时有这么几种情况： 1、使用 “gcc -o libdynamic.so -shared -fPIC -L. -lstatic dynamic.o “，连接成功，但.so里实际上没有static.o里的内容。 2、使用"gcc -o libdynamic.so dynamic.o -shared -fPIC -L. -lstatic”,连接失败 3、使用 “gcc -o libdynamic.so -shared -fPIC -L. -lstatic_shared dynamic.o”，连接成功，但.so里实际上没有static.o里还是没有的内容。 4、使用 “gcc -o libdynamic.so dynamic.o -shared -fPIC -L. -lstatic_shared”,连接成功，.a的内容被连接到了.so里面。另外，链接静态生成可执行程序时，静态库是不是用 “-shared -fPIC” 选项编译产生的没有影响。都能正常生成可执行程序。综合以上情况，总结如下： 1、动态连接库中用到的object文件必须是用 “-shared -fPIC"选项编译产生的，否则连接时要么报错，要么被忽略。 2、静态库中的object文件最好也用”-shared -fPIC"选项编译，这样静态库就可以同时被连接到.so 或者可执行性文件中。 3、动态库只能连接用”-shared -fPIC"选项编译出来的静态库（和第1点是同一件事） 4、连接选项的顺序对连接器的行为有重要影响！静态库使用-shared -fPIC 连接命令连接执行结果动态库结果最终结果否 gcc -o libdynamic.so -shared -fPIC -L. -lstatic dynamic.o 成功静态库内容没有被连接失败否 gcc -o libdynamic.so dynamic.o -shared -fPIC -L. -lstatic 失败失败是 gcc -o libdynamic.so -shared -fPIC -L. -lstatic_shared dynamic.o 成功静态库内容没有被连接失败是 gcc -o libdynamic.so dynamic.o -shared -fPIC -L. -lstatic_shared 成功静态库内容被连接成功

直接链接 lib.a 的文件，会报错，要求 fPIC，看到这个文章，http://hi.baidu.com/88908775/item/4c147df59c218d1fa62988c6，里面提供了两种方式，一个改 configure，一个是改 Makefile，改 Makefile 在我这个尝试了不行，改 configure 可以

环境： gcc (GCC) 4.1.2 20070115 (prerelease) (SUSE Linux) 64位

google protobuf 2.4.1

问题：在使用libprotobuf.a文件时，编译错误 libprotobuf.a(common.o): relocation R_X86_64_32S against `std::basic_string, std::allocator >::_Rep::_S_empty_rep_storage’ can not be used when making a shared object; recompile with -fPIC

原因： -fPIC 是个神马东东呢？选项 -fPIC PIC是Position-Independent-Code的缩写。在计算机系统中，PIC和PIE(Position-IndependentExecutable)是可以在主存中不同位置执行的目标代码。PIC经常被用在共享库中，这样就能将相同的库代码为每个程序映射到一个位置，不用担心覆盖掉其他程序或共享库。

因为so动态库编译的时候加上了 -fPIC，但是连接的 libprotobuf.a文件并不是 -fPIC生成的，所以就报错了。那就是说连接的 libprotobuf.aa 文件，也需要加上 -fPIC 选项进行编译了。

解决方法：

以文本形式打开google buff代码目录下的configure文件，在把第2575至2578行修改为如下： if test “x${ac_cv_env_CFLAGS_set}” = “x”; then : CFLAGS="-fPIC" fi if test “x${ac_cv_env_CXXFLAGS_set}” = “x”; then : CXXFLAGS="-fPIC" 再次执行configure： configrue –disable-shared make make install 编译完成后,使用libprotobuf.a文件，以上问题解决。

或者修改 google protobuf的 Makefile文件，加上 -fPIC 选项，重新编译生成 libprotobuf.a文件

参考资料：

详细说明-fPIC的工作原理： http://blog.csdn.net/chrisniu1984/article/details/6620665

-DPIC 是一个宏定义预处理标识 http://gcc.gnu.org/ml/gcc-help/2006-10/msg00147.html

http://www.lingcc.com/2009/11/20/10065/ http://canlynet.blog.163.com/blog/static/25501365201191145113156/ 编译动态库时遇到如下错误： … … relocation R_X86_64_32 against `a local symbol’ can not be used when making a shared object; recompile with -fPIC … could not read symbols: Bad value

解决办法编译器已经提示了：recompile with -fPIC 但是我们应该重新编译谁带上这个参数呢？经过我几番折腾，发现如下情况： 1、编译.o文件的时候，没有加参数-fPIC，这问题个在gcc version 3.4.6版本没有发生，可能那个编译器默认都给加上吧。 2、当前程序中有用到某个静态库，那个静态库编译.o文件的时候没有加上-fPIC（静态库其实就是.o文件打包）。补充一点：我发现手写Makefile时即使不加-fPIC也没有这个问题，这一点很郁闷，这个只在用automake工具编译出.a文件时才出现过。知道原因了，解决办法自然有了，保证你编译.o文件的时候，都加上-fPIC，这样你才能编译出动态库来。

http://bbs.chinaunix.net/thread-1035042-1-1.html 从GCC来看，shared应该是包含fPIC选项的，但似乎不是所以系统都支持，所以最好显式加上fPIC选项。参见如下

`-shared’ Produce a shared object which can then be linked with other objects to form an executable. Not all systems support this option. For predictable results, you must also specify the same set of options that were used to generate code (`-fpic’, `-fPIC’, or model suboptions) when you specify this option.(1)

gcc 编译时输出有问号

Tue, 31 Dec 2013 11:20:18 +0800

今天切到一台新的机器上去开发，编译的时候发现 gcc 的输出带着问号，就像这个样子

src/BusiObj.cpp: In member function ?.nt CBusiObj::DecodeUdp(int&, int&, const char*, int)?.
src/BusiObj.cpp:287: warning: format ?.d?.expects type ?.nt?. but argument 6 has type ?.ong unsigned int?
src/BusiObj.cpp:300: warning: format ?.u?.expects type ?.nsigned int?. but argument 7 has type ?._time_t?

看起来十分难受，查了一下是终端字符编码的问题，用 echo $LANG 看一下系统的编码，把终端的编码跟随的调整一下就可以了，修改完成后就是正常的了

src/BusiObj.cpp: In member function ‘int CBusiObj::DecodeUdp(int&, int&, const char*, int)’:
src/BusiObj.cpp:287: warning: format ‘%d’ expects type ‘int’, but argument 6 has type ‘long unsigned int’
src/BusiObj.cpp:300: warning: format ‘%u’ expects type ‘unsigned int’, but argument 7 has type ‘__time_t’

netstat 查看连接的时候打印进程名

Fri, 27 Dec 2013 17:35:38 +0800

这个本来是个很基本的需求啊，搜了一下，stackover flow 上面有讨论，在这里，http://stackoverflow.com/questions/4247932/how-to-parse-netstat-command-in-order-to-get-process-name-and-pid-from-it/20798071#20798071

Try

ps -p $(lsof -ti tcp:80) o comm=,pid= or

netstat -tlnp | awk ‘/:80 */ {split($NF,a,"/"); print a[2],a[1]}’

好麻烦，而且跑不了，后来发现加一个 -p 参数就可以了。。

netstat -p

不过需要 root 权限

Linux 下删除乱码文件名的文件

Fri, 27 Dec 2013 16:04:46 +0800

使用 rz 往服务器上传文件的时候，出错了，遗留下来的文件名是乱码，这个问题，使用 rz -be 可以解决，可以顺利上传文件，但是在删除残留文件的时候发现悲剧了，查了一下看到这里，http://www.jb51.net/LINUXjishu/32910.html

linux下删除乱码文件名, 不废话:

1. ls -i 列出文件的节点ID, 如: 123456789

2. find ./ -inum 123456789 -print -exec rm -rf {} \;

批量删除:

for n in 123456789 987654321;do find . -inum $n -exec rm -f {} \;;done

有更简便的方法欢迎告知~

基本可以解决问题，要是想少敲几个字母，可以这样子写

find ./ -inum 52003472 | xargs rm

pthread_self 和 gettid 的性能区别

Wed, 18 Dec 2013 18:00:51 +0800

打日志的时候，我们希望把线程 id 打印出来，线程 id 有两个方法可以获取，gettid 和 pthread_self，前者是一个 Linux 的系统调用，后者是一个可移植的库函数，可移植性倒还好，因为也不怎么考虑跨平台，另外一个区别，就是他们的返回值不一样，这个可以看到这里，http://stackoverflow.com/questions/6372102/what-is-the-difference-between-pthread-self-and-gettid-which-one-should-i-u，有一个讨论，摘录如下：

They are not the same. Here are some bits I collected from TLPI (I couldn’t find a large-enough block that completely describes this). If you’re in a hurry you probably want just the last part.

gettid

Linux 2.4 introduced a new system call, gettid(), to allow a thread to obtain its own thread ID.

Each thread within a thread group is distinguished by a unique thread identifier. A thread ID is represented using the same data type that is used for a process ID, pid_t. Thread IDs are unique system-wide, and the kernel guarantees that no thread ID will be the same as any process ID on the system, except when a thread is the thread group leader for a process.

pthread_self

Each thread within a process is uniquely identified by a thread ID. A thread can obtain its own ID using pthread_self().

The pthread_equal() function is needed to compare thread ids because the pthread_t data type must be treated as opaque data.

In the Linux threading implementations, thread IDs are unique across processes. However, this is not necessarily the case on other implementations, and SUSv3 explicitly notes that an application can’t portably use a thread ID to identify a thread in another process.

gettid vs pthread_self

POSIX thread IDs are not the same as the thread IDs returned by the Linux-specific gettid() system call. POSIX thread IDs are assigned and maintained by the threading implementation. The thread ID returned by gettid() is a number (similar to a process ID) that is assigned by the kernel.

I would go with pthread_setaffinity_np but be aware that the manual says:

These functions are implemented on top of the sched_setaffinity(2)

简单的说，就是一个是给出系统范围内的唯一 id，另外一个是给出进程范围内的唯一值，这个也不太重要吧，另外这里，给出了一些源码的跟踪，http://zhwen.org/xlog/?p=622，接下来就是考虑性能问题了，首先来看 pthread_self

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/syscall.h>
#include <pthread.h>
#include <iostream>

#define gettid() syscall(__NR_gettid)  

int main() {
    //pid_t tid;
    pthread_t tid;
    int iTestCase = 10000000;
    while (iTestCase--) {
        //tid = gettid();
        tid = pthread_self();
        tid++;
    }
    std::cout<<tid<<std::endl;
    return 0;
}

那个自增，是为了防止编译器优化，输出如下

$ time ./a.out 
47071132892337

real	0m0.036s
user	0m0.036s
sys	0m0.000s

话说这个 id 还真是长啊。。然后来看看 gettid 的情况

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/syscall.h>
#include <pthread.h>
#include <iostream>

#define gettid() syscall(__NR_gettid)  

int main() {
    pid_t tid;
    //pthread_t tid;
    int iTestCase = 10000000;
    while (iTestCase--) {
        tid = gettid();
        //tid = pthread_self();
        tid++;
    }
    std::cout<<tid<<std::endl;
    return 0;
}

来看耗时

$ time ./a.out 
3904

real	0m0.543s
user	0m0.236s
sys	0m0.308s

居然慢了几乎 18 倍，这个差距就太大了

STL set 的一些实现差异

Wed, 18 Dec 2013 11:32:18 +0800

侯捷大师在 STL 源码剖析中说道，set 的迭代器的值是不可改变的，这个本来很好理解，但是我神奇的在 visual studio 2005 上发现，神奇的事情总是会发生

#include <stdio.h>
#include <map>
#include <string>
#include <set>

int main() {
    std::set<int> setInt;
    setInt.insert(1);
    setInt.insert(2);
    for (std::set<int>::iterator it = setInt.begin(); it != setInt.end(); it++)
    {
        printf("%d\n", *it);
    }
    {
        std::set<int>::iterator it = setInt.begin();
        *it = 4;
        it++;
        *it = 3;
    }
    for (std::set<int>::iterator it = setInt.begin(); it != setInt.end(); it++)
    {
        printf("%d\n", *it);
    }
    return 0;
}

居然顺利的编译通过，而且可以跑，看看输出

1
2
4
3
请按任意键继续. . .

照理说，set 的底下是红黑树的话，这里应该是会违反红黑树的大小排序原则的。。

甚至改成这样

#include <stdio.h>
#include <map>
#include <string>
#include <set>

int main() {
    std::set<int> setInt;
    setInt.insert(1);
    setInt.insert(2);
    for (std::set<int>::iterator it = setInt.begin(); it != setInt.end(); it++)
    {
        printf("%d\n", *it);
    }
    {
        std::set<int>::iterator it = setInt.begin();
        *it = 4;
        it++;
        *it = 4;
    }
    for (std::set<int>::iterator it = setInt.begin(); it != setInt.end(); it++)
    {
        printf("%d\n", *it);
    }
    return 0;
}

也可以。。好吧，set 的原则也被破坏了。。

来看 gcc 4.1 的编译输出

StlContainerTest.cpp:25:2: warning: no newline at end of file
StlContainerTest.cpp: In function 'int main()':
StlContainerTest.cpp:16: error: assignment of read-only location
StlContainerTest.cpp:18: error: assignment of read-only location

这个才是符合预期的嘛，M$ 这样会坑死人啊。。

基于队列的 UDP 多线程收发 demo

Tue, 10 Dec 2013 15:46:01 +0800

来看这个代码

#include <stdio.h>
#include <assert.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <fcntl.h>
#include <string.h>
#include <sys/epoll.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <queue>
#include <pthread.h>

#define _PRINTF_(format, ...) printf("[%s:%20s@%20s,%04d] " format "\n", "DEBUG",__FUNCTION__, __FILE__, __LINE__, ##__VA_ARGS__ );

static const int iBufferSize = 2048;
int iUdpServerFd;
static const unsigned short uiUdpServerPort = 6000;
static const int iUdpProcessThreadNumber = 2;

struct InQueueEvent
{
    struct sockaddr_in stClientAddr;
    socklen_t stClienAddrLen;
    char szRecvBuffer[iBufferSize];
    int iRecvLen;
};

struct OutQueueEvent
{
    struct sockaddr_in stDestAddr;
    socklen_t stDestAddrLen;
    char szSendBuffer[iBufferSize];
    int iSendContentLen;
};

std::queue<struct InQueueEvent> stInQueue;
pthread_mutex_t stInQueueMutex;
std::queue<struct OutQueueEvent> stOutQueue;
pthread_mutex_t stOutQueueMutex;

void* UdpProcessThread(void*)
{
    _PRINTF_("udp process thread %ld start", pthread_self());
    while (1)
    {
        if (stInQueue.empty())
        {
            continue;
        }
        pthread_mutex_lock(&stInQueueMutex);
        struct InQueueEvent stInQueueEvent = stInQueue.front();
        stInQueue.pop();
        pthread_mutex_unlock(&stInQueueMutex);
        _PRINTF_("thread %ld processing the request %s", pthread_self(), stInQueueEvent.szRecvBuffer);
        struct OutQueueEvent stOutQueueEvent;
        stOutQueueEvent.stDestAddr = stInQueueEvent.stClientAddr;
        stOutQueueEvent.stDestAddrLen = stInQueueEvent.stClienAddrLen;
        memcpy(stOutQueueEvent.szSendBuffer, stInQueueEvent.szRecvBuffer, stInQueueEvent.iRecvLen);
        stOutQueueEvent.iSendContentLen = stInQueueEvent.iRecvLen;
        pthread_mutex_lock(&stOutQueueMutex);
        stOutQueue.push(stOutQueueEvent);
        pthread_mutex_unlock(&stOutQueueMutex);        
    }
}

void* UdpRecvThread(void*)
{
    _PRINTF_("udp recv thread start");
    while(1)
    {
        struct InQueueEvent stInQueueEvent;
        memset(&stInQueueEvent, 0, sizeof(stInQueueEvent));
        stInQueueEvent.stClienAddrLen = sizeof(stInQueueEvent.stClientAddr);
        stInQueueEvent.iRecvLen = recvfrom(iUdpServerFd, &(stInQueueEvent.szRecvBuffer), sizeof(stInQueueEvent.szRecvBuffer), 0, (struct sockaddr*)&(stInQueueEvent.stClientAddr), &(stInQueueEvent.stClienAddrLen));
        _PRINTF_("recv %d bytes from ip %s port %d message %s", stInQueueEvent.iRecvLen, inet_ntoa(stInQueueEvent.stClientAddr.sin_addr), ntohs(stInQueueEvent.stClientAddr.sin_port), stInQueueEvent.szRecvBuffer);
        pthread_mutex_lock(&stInQueueMutex);
        stInQueue.push(stInQueueEvent);
        pthread_mutex_unlock(&stInQueueMutex);
    }
}

void* UdpSendThread(void*)
{
    _PRINTF_("udp send thread start");
    while(1)
    {
        if (stOutQueue.empty())
        {
            continue;
        }
        pthread_mutex_lock(&stOutQueueMutex);
        struct OutQueueEvent stOutQueueEvent = stOutQueue.front();
        stOutQueue.pop();
        pthread_mutex_unlock(&stOutQueueMutex);
        int iSendLen = sendto(iUdpServerFd, &(stOutQueueEvent.szSendBuffer), stOutQueueEvent.iSendContentLen, 0, (struct sockaddr*)&(stOutQueueEvent.stDestAddr), stOutQueueEvent.stDestAddrLen);
        _PRINTF_("send %d bytes to ip %s port %d message %s", iSendLen, inet_ntoa(stOutQueueEvent.stDestAddr.sin_addr), ntohs(stOutQueueEvent.stDestAddr.sin_port), stOutQueueEvent.szSendBuffer);
    }
}

int CreateUdpServer(unsigned short uiUdpServerPort)
{
    int iListenFd = socket(AF_INET, SOCK_DGRAM, 0);
    assert(iListenFd > 0);
    struct sockaddr_in stListenAddr;
    memset(&stListenAddr, 0, sizeof(stListenAddr));
    stListenAddr.sin_family = AF_INET;
    stListenAddr.sin_addr.s_addr = htonl(INADDR_ANY);
    stListenAddr.sin_port = htons(uiUdpServerPort);
    int iReuseFlag = 1;
    assert(setsockopt(iListenFd, SOL_SOCKET, SO_REUSEADDR, &iReuseFlag, sizeof(int)) == 0);
    assert(bind(iListenFd, (struct sockaddr*)&stListenAddr, sizeof(stListenAddr)) == 0);  
    return iListenFd;
}

int main()
{
    pthread_mutex_init(&stInQueueMutex, NULL);
    pthread_mutex_init(&stOutQueueMutex, NULL);
    iUdpServerFd = CreateUdpServer(uiUdpServerPort);
    pthread_t tid;
    assert(pthread_create(&tid, NULL, UdpRecvThread, NULL) == 0);
    assert(pthread_create(&tid, NULL, UdpSendThread, NULL) == 0);
    for (int i = 0; i < iUdpProcessThreadNumber; i++)
    {
        assert(pthread_create(&tid, NULL, UdpProcessThread, NULL) == 0);
    }    
    while (1)
    {
        sleep(10);
    }
    return 0;
}

用 python 写个客户端测试一下

#!/usr/bin/env python

import socket

HOST = 'xx.xx.xx.xx'
PORT = 6000
BUFSIZ = 1024
ADDR = (HOST, PORT)

udpCliSock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

while True:
    data = raw_input('> ')
    if not data:
        break
    udpCliSock.sendto(data, ADDR)
    data, ADDR = udpCliSock.recvfrom(BUFSIZ)
    if not data:
        break
    print ADDR, data

udpCliSock.close()

跑起来似乎没有问题

[DEBUG:       UdpRecvThread@        EpollUdp.cpp,0069] udp recv thread start
[DEBUG:       UdpSendThread@        EpollUdp.cpp,0085] udp send thread start
[DEBUG:    UdpProcessThread@        EpollUdp.cpp,0044] udp process thread 1107310912 start
[DEBUG:    UdpProcessThread@        EpollUdp.cpp,0044] udp process thread 1098918208 start
[DEBUG:       UdpRecvThread@        EpollUdp.cpp,0076] recv 1 bytes from ip 10.31.18.40 port 62272 message 1
[DEBUG:    UdpProcessThread@        EpollUdp.cpp,0055] thread 1107310912 processing the request 1
[DEBUG:       UdpSendThread@        EpollUdp.cpp,0097] send 1 bytes to ip 10.31.18.40 port 62272 message 1
[DEBUG:       UdpRecvThread@        EpollUdp.cpp,0076] recv 1 bytes from ip 10.31.18.40 port 62272 message 2
[DEBUG:    UdpProcessThread@        EpollUdp.cpp,0055] thread 1107310912 processing the request 2
[DEBUG:       UdpSendThread@        EpollUdp.cpp,0097] send 1 bytes to ip 10.31.18.40 port 62272 message 2

但是多发几次，就 core 了，这是为什么呢，gdb 调试发现 core 在 memcpy 上面，这个也不太能理解，不过，把代码尝试的改成这样就可以了

#include <stdio.h>
#include <assert.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <fcntl.h>
#include <string.h>
#include <sys/epoll.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <queue>
#include <pthread.h>

#define _PRINTF_(format, ...) printf("[%s:%20s@%20s,%04d] " format "\n", "DEBUG",__FUNCTION__, __FILE__, __LINE__, ##__VA_ARGS__ );

static const int iBufferSize = 2048;
int iUdpServerFd;
static const unsigned short uiUdpServerPort = 6000;
static const int iUdpProcessThreadNumber = 2;

struct InQueueEvent
{
    struct sockaddr_in stClientAddr;
    socklen_t stClienAddrLen;
    char szRecvBuffer[iBufferSize];
    int iRecvLen;
};

struct OutQueueEvent
{
    struct sockaddr_in stDestAddr;
    socklen_t stDestAddrLen;
    char szSendBuffer[iBufferSize];
    int iSendContentLen;
};

std::queue<struct InQueueEvent> stInQueue;
pthread_mutex_t stInQueueMutex;
std::queue<struct OutQueueEvent> stOutQueue;
pthread_mutex_t stOutQueueMutex;

void* UdpProcessThread(void*)
{
    _PRINTF_("udp process thread %ld start", pthread_self());
    while (1)
    {
        pthread_mutex_lock(&stInQueueMutex);
        if (stInQueue.empty())
        {
            pthread_mutex_unlock(&stInQueueMutex);
            continue;
        }
        struct InQueueEvent stInQueueEvent = stInQueue.front();
        stInQueue.pop();
        pthread_mutex_unlock(&stInQueueMutex);
        _PRINTF_("thread %ld processing the request %s", pthread_self(), stInQueueEvent.szRecvBuffer);
        struct OutQueueEvent stOutQueueEvent;
        memset(&stOutQueueEvent, 0, sizeof(stOutQueueEvent));
        stOutQueueEvent.stDestAddr = stInQueueEvent.stClientAddr;
        stOutQueueEvent.stDestAddrLen = stInQueueEvent.stClienAddrLen;
        memcpy(stOutQueueEvent.szSendBuffer, stInQueueEvent.szRecvBuffer, stInQueueEvent.iRecvLen);
        stOutQueueEvent.iSendContentLen = stInQueueEvent.iRecvLen;
        pthread_mutex_lock(&stOutQueueMutex);
        stOutQueue.push(stOutQueueEvent);
        pthread_mutex_unlock(&stOutQueueMutex);        
    }
}

void* UdpRecvThread(void*)
{
    _PRINTF_("udp recv thread start");
    while(1)
    {
        struct InQueueEvent stInQueueEvent;
        memset(&stInQueueEvent, 0, sizeof(stInQueueEvent));
        stInQueueEvent.stClienAddrLen = sizeof(stInQueueEvent.stClientAddr);
        stInQueueEvent.iRecvLen = recvfrom(iUdpServerFd, &(stInQueueEvent.szRecvBuffer), sizeof(stInQueueEvent.szRecvBuffer), 0, (struct sockaddr*)&(stInQueueEvent.stClientAddr), &(stInQueueEvent.stClienAddrLen));
        _PRINTF_("recv %d bytes from ip %s port %d message %s", stInQueueEvent.iRecvLen, inet_ntoa(stInQueueEvent.stClientAddr.sin_addr), ntohs(stInQueueEvent.stClientAddr.sin_port), stInQueueEvent.szRecvBuffer);
        pthread_mutex_lock(&stInQueueMutex);
        stInQueue.push(stInQueueEvent);
        pthread_mutex_unlock(&stInQueueMutex);
    }
}

void* UdpSendThread(void*)
{
    _PRINTF_("udp send thread start");
    while(1)
    {
        pthread_mutex_lock(&stOutQueueMutex);
        if (stOutQueue.empty())
        {
            pthread_mutex_unlock(&stOutQueueMutex);
            continue;
        }
        struct OutQueueEvent stOutQueueEvent = stOutQueue.front();
        stOutQueue.pop();
        pthread_mutex_unlock(&stOutQueueMutex);
        int iSendLen = sendto(iUdpServerFd, &(stOutQueueEvent.szSendBuffer), stOutQueueEvent.iSendContentLen, 0, (struct sockaddr*)&(stOutQueueEvent.stDestAddr), stOutQueueEvent.stDestAddrLen);
        _PRINTF_("send %d bytes to ip %s port %d message %s", iSendLen, inet_ntoa(stOutQueueEvent.stDestAddr.sin_addr), ntohs(stOutQueueEvent.stDestAddr.sin_port), stOutQueueEvent.szSendBuffer);
    }
}

int CreateUdpServer(unsigned short uiUdpServerPort)
{
    int iListenFd = socket(AF_INET, SOCK_DGRAM, 0);
    assert(iListenFd > 0);
    struct sockaddr_in stListenAddr;
    memset(&stListenAddr, 0, sizeof(stListenAddr));
    stListenAddr.sin_family = AF_INET;
    stListenAddr.sin_addr.s_addr = htonl(INADDR_ANY);
    stListenAddr.sin_port = htons(uiUdpServerPort);
    int iReuseFlag = 1;
    assert(setsockopt(iListenFd, SOL_SOCKET, SO_REUSEADDR, &iReuseFlag, sizeof(int)) == 0);
    assert(bind(iListenFd, (struct sockaddr*)&stListenAddr, sizeof(stListenAddr)) == 0);  
    return iListenFd;
}

int main()
{
    pthread_mutex_init(&stInQueueMutex, NULL);
    pthread_mutex_init(&stOutQueueMutex, NULL);
    iUdpServerFd = CreateUdpServer(uiUdpServerPort);
    pthread_t tid;
    assert(pthread_create(&tid, NULL, UdpRecvThread, NULL) == 0);
    assert(pthread_create(&tid, NULL, UdpSendThread, NULL) == 0);
    for (int i = 0; i < iUdpProcessThreadNumber; i++)
    {
        assert(pthread_create(&tid, NULL, UdpProcessThread, NULL) == 0);
    }    
    while (1)
    {
        sleep(10);
    }
    return 0;
}

注意高亮的部分，在检查队列是否为空的时候，也要包含在锁的区域里面，这样就可以了

-———————————————

2013-12-10 16:37:06 update 使用这个脚本，可以多线程压测服务

#!/usr/bin/env python

import socket
import random
import threading

HOST = 'xx.xx.xx.xx'
PORT = 6000
BUFSIZ = 1024
ADDR = (HOST, PORT)

class UdpTestThread(threading.Thread):
    def run(self):
        udpCliSock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        for i in range(1000):
            data = str(random.random())
            udpCliSock.sendto(data, ADDR)
            data = udpCliSock.recvfrom(BUFSIZ)
            #print data
        udpCliSock.close()

for i in range(50):
    UdpTestThread().start()

-—————————

2013-12-10 17:21:05 update 发现上面的例子，压测结果很差，于是写了个极简的，作为比对

#include <sys/socket.h>
#include <arpa/inet.h>

int main() {
    int fd = socket(AF_INET, SOCK_DGRAM, 0);
    struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_port = htons(6000);
    addr.sin_addr.s_addr = htonl(INADDR_ANY);
    bind(fd, (struct sockaddr*)&addr, sizeof(addr));
    while (1) {
        char buffer[2048] = {0};
        struct sockaddr cli;
        socklen_t cli_len = sizeof(cli);
        int recv_len = recvfrom(fd, buffer, sizeof(buffer), 0, &cli, &cli_len);
        sendto(fd, buffer, recv_len, 0, &cli, cli_len);
    }
    return 0;
}

发现差不多，看来还要找原因

历史评论

wanax (2014-03-19 16:52:29):

这几天挖出来个GLib的，自带线程池和宏定义好了的锁，感觉再用C就顺手多了

ZRJ (2014-03-19 20:15:41):

其实用 libevent 基本就够了，不用造轮子

wanax (2014-03-20 09:49:23):

那玩意儿就是个轮子还附带各种数据结构与常用工具类

ZRJ (2014-03-20 19:58:08):

反正我现在是觉得能有稳定开源的就用呗

Linux 查看两个文件的交集

Thu, 05 Dec 2013 09:59:42 +0800

这个是很常见的需求，假如两个文件

123
456
789

123
789
abc

我等劳模，上来就挽袖子，自己写脚本了

#!/usr/bin/env python

import sys

def calc_uniq(file1, file2):
    file1 = open(file1)
    file2 = open(file2)
    set1 = set()
    set2 = set()
    for line in file1:
        set1.add(line)
    for line in file2:
        set2.add(line)
    set_intersection = set1 & set2
    print file1.name, "uniq item:", len(set1)
    print file2.name, "uniq item:", len(set2)
    print "intersection len:", len(set_intersection)
    print "intersection detail:"
    print set_intersection
    file1.close()
    file2.close()
    
if __name__ == "__main__":
    if len(sys.argv) == 3:
        calc_uniq(sys.argv[1], sys.argv[2])
    else:
        print "this script calculate the intersection of two files"
        print "usage:", sys.argv[0], "path_to_file1 path_to_file2"

倒也能跑

1 uniq item: 3
2 uniq item: 3
intersection len: 2
intersection detail:
set(['789\n', '123\n'])

但是搜一下，看到这里，http://blogread.cn/it/article/356

1. 取出两个文件的并集(重复的行只保留一份)

cat file1 file2 | sort | uniq

2. 取出两个文件的交集(只留下同时存在于两个文件中的文件)

cat file1 file2 | sort | uniq -d

3. 删除交集，留下其他的行

cat file1 file2 | sort | uniq -u

感觉瞬间挫爆了，辛辛苦苦那么多行，人家一行就搞定

但是，等等，看看这个用例

123
123

456
456

来看输出

$ cat 1 2 | sort | uniq -d
123
456

傻了吧

不过另外又看到这里，http://www.commandlinefu.com/commands/view/5710/intersection-between-two-files

grep -Fx -f file1 file2

这个更加霸气啊，而且还不出错，真是把 shell 玩出花了

gcc 查看链接库路径

Wed, 04 Dec 2013 13:01:14 +0800

当我们想知道 gcc 在链接的时候使用了什么库的时候，可以使用这样的命令

$ gcc --print-file-name=librt.so 
/usr/lib64/gcc/x86_64-suse-linux/4.1.2/../../../../lib64/librt.so

之前用过一次，今天再用的时候差点又忘了，简单记一下

libevent 库上手

Thu, 14 Nov 2013 09:46:42 +0800

先来看一个基于定时器的事件驱动

#include <stdio.h>
#include <event.h>

void onTime(int sock, short event, void* arg) {
    printf("hi there\n");
    struct timeval tv;
    tv.tv_sec = 1;
    tv.tv_usec = 0;
    event_add((struct event*)arg, &tv);
}

int main() {
    event_init();
    struct event evTime;
    evtimer_set(&evTime, onTime, &evTime);
    struct timeval tv;
    tv.tv_sec = 1;
    tv.tv_usec = 0;
    event_add(&evTime, &tv);
    event_dispatch();
    return 0;
}

可以看到流程还是比较清晰简单的，下面再看一个 socket 事件的回调

#include <stdio.h>
#include <assert.h>
#include <event.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>

struct event_base* base;

void onRead(int iCliFd, short iEvent, void* arg) {
    char buf[8192];
    int iLen = recv(iCliFd, buf, 8192, 0);
    if (iLen <= 0) {
        printf("cli close\n");
        struct event* pEvRead = (struct event*)arg;
        event_del(pEvRead);
        delete pEvRead;

        close(iCliFd);
        return;
    }
    buf[iLen] = 0;
    printf("cli info:\n------------------------\n%s------------------------\n", buf);
}

void onAccept(int iSvrFd, short iEvent, void* arg) {
    struct sockaddr_in stCliAddr;
    socklen_t iSinSize = sizeof(stCliAddr);
    int iCliFd = accept(iSvrFd, (struct sockaddr*)&stCliAddr, &iSinSize);
    struct event* pEvRead = new event;
    event_set(pEvRead, iCliFd, EV_READ|EV_PERSIST, onRead, pEvRead);
    event_base_set(base, pEvRead);
    event_add(pEvRead, NULL);
}

int main() {
    int iSvrFd = socket(AF_INET, SOCK_STREAM, 0);
    assert(iSvrFd != -1);
    struct sockaddr_in stSvrAddr;
    memset(&stSvrAddr, 0, sizeof(stSvrAddr));
    stSvrAddr.sin_family = AF_INET;
    stSvrAddr.sin_addr.s_addr = INADDR_ANY;
    stSvrAddr.sin_port = htons(8080);
    assert(bind(iSvrFd, (struct sockaddr*)&stSvrAddr, sizeof(stSvrAddr)) != -1);
    assert(listen(iSvrFd, 10) != -1);
    
    base = event_base_new();
    struct event evListen;
    event_set(&evListen, iSvrFd, EV_READ|EV_PERSIST, onAccept, NULL);
    event_base_set(base, &evListen);
    event_add(&evListen, NULL);
    event_base_dispatch(base);

    return 0;
}

附上 Makefile

INC += -I/home/adenzhang/tools/libevent-2.0.21-stable/include/

LIB += -L/home/adenzhang/tools/libevent-2.0.21-stable/lib/ -levent

all:
	g++ -g -Wall -o libevent_time_echo libevent_time_echo.cpp $(INC) $(LIB)
	g++ -g -Wall -o libevent_tcp_echo libevent_tcp_echo.cpp $(INC) $(LIB)

一开始编译的时候报 event_base_new 函数没有实现，后来才发现是机器上的库的版本太老，使用这个命令可以看到链接时使用的具体文件

gcc -print-file-name=libevent.so

下载一个 2.x 的库就可以了，安装也就是 ./configure && make && make install 三部曲，挺顺利没有遇到问题

对于 libevent 的基本理解可以看到这里，http://www.cnblogs.com/cnspace/archive/2011/07/19/2110891.html，详细的源码分析看到这里，http://blog.csdn.net/sparkliang/article/details/4957667

其实可以看到，libevent 在写 socket 上，跟 epoll 的感觉还是差不多的，而实际上 libevent 在 linux 上也是基于 epoll 的，那么其实可以直接用 epoll，如果在不考虑可移植性的情况下。

历史评论

TonySeek (2014-01-03 02:51:22):

Node.js 的 libuv 比 libevent/libev 好用

ZRJ (2014-01-03 20:54:30):

node js 那么潮爆的东西，还是自己的 weekend 项目用用就算了，在生产环境还是别想了，为了稳定，保守到什么程度，看着 c++11 和 boost 的智能指针封装好了干着急不能用，想要 RAII？自己写封装。代码写起来累点苦力点没关系，甚至运行效率低点也可以堆机器，但是服务器上跑了六七年的代码改一下都要很小心，引入新的第三方库都要评估，何况换语言。。

TonySeek (2014-01-03 21:12:32):

不是用 Node.js 啊，是用 libuv 啊～设计的很不错的库～

而且源码量也不大，自己大概浏览一遍就有安全感了 : )

ZRJ (2014-01-04 09:37:34):

搜了一下看到云风的 blog 有说道，看起来还行。。不过我们最终的生产环境还是没有用第三方库，自己写了事件驱动。。真是造轮子。。

TonySeek (2014-01-04 12:25:28):

自己造轮子如果造得圆还好了…… 我比较受不了放着开源的不用自己造轮子，造出来还是方的……

gcc 编译选项顺序导致的找不到定义

Thu, 12 Sep 2013 09:47:05 +0800

在使用 gcc 或者 g++ 进行编译，并链接外部的库的时候，发现了一个问题，明明使用了 -L 参数对库文件指明了链接，但是依然出错，报找不到定义，后来问过小组的人，才知道 gcc 的编译选项也有讲究的，看到这里，http://blog.csdn.net/lonfee88/article/details/6029540：

对于C/C++编译而言，读取编译选项是按照从左到右的顺序执行的(注1) 。那么当编译器遇到源文件的时候，就开始对源文件中用到的函数进行解析，找到相对应的函数的函数体或者说是实现（Definition of Function）。这个过程是按照先遇到不能解析的函数（unresolved function），然后在源文件选项后面的一些选项中寻找可能的函数体的信息，是这样的一个顺序进行的。那么我们可以发现对于Makefile A，由于包含函数体或者函数定义信息的编译选项出现在源文件之前，那么当编译器在源文件中遇到不能解析的函数时，在源文件之后的选项中寻找相关的信息，那么就出现了编译错误，也就是无法找到相关的函数定义。

所以解决的方式是，把链接的 -L 选项放到后面去

写一个日志模块

Thu, 05 Sep 2013 20:48:27 +0800

今天在写一个日志模块，遇到一些问题，学到了一些东西，记一下。

一开始想到，cpp 这么成熟的社区，日志这么基本的模块，应该现成的有很多吧，随便找一个来用就可以了，上网搜了一圈，发现真是一团混乱啊，看到这里，http://blog.csdn.net/junchaox/article/details/7346514

待选为 glog、log4cplus、log4cpp、log4cxx

目前准备使用glog，使用方便，性能也不错，待进一步试验，如果有不能满足的功能就转用 log4cplus，功能很全面，不过稍复杂些。

其它两个都是三年前就没更新，没好感，暂不准备使用。

1.log4cplus 最新版本：1.1.0 2012-03-11

下载地址：http://sourceforge.net/projects/log4cplus/files/log4cplus-stable/1.1.0

功能全面，使用稍复杂。

代码示例：

#include <log4cplus/layout.h>  
  
#include <log4cplus/configurator.h>  
  
#include <iomanip>  
  
SharedAppenderPtr pFileAppender(new FileAppender("testlog.log"));  
  
Logger pTestLogger = Logger::getInstance("LoggerName");  
  
pTestLogger.addAppender(pFileAppender);   
  
sprintf(a,"%d",i);  
  
LOG4CPLUS_WARN(pTestLogger, "This is a <Warn> log message..." << a );

2.log4cxx 最新版本： 0.10.0 2008-04-03

下载地址：http://logging.apache.org/log4cxx/download.html 编译很麻烦新的版本0.10.0需要使用Apache的产品Ant来编译，而Ant又需要JDK。。。

怕麻烦，没有下载测试。

3. glog 最新版本： 0.3.2 2012-1-12

下载地址：http://code.google.com/p/google-glog/downloads/list

使用方便，性能也不错。

Google Glog 是一个C++语言的应用级日志记录框架，提供了 C++ 风格的流操作和各种助手宏。

Google glog是一个基于程序级记录日志信息的c++库，编程使用方式与c++的stream操作类似

代码示例：

#include <glog/logging.h>  
  
google::InitGoogleLogging(argv[0]);  
  
google::SetLogDestination(google::INFO,"./myInfo_");  
  
LOG(INFO) << "This is a <Warn> log message..." << i;

Log4cpp 最新版1.0.x 2007-09-03

下载地址： http://sourceforge.net/projects/log4cpp/files

感觉跟 log4cplus类似，结构稍简单些，不过代码也不少写。

#include <log4cpp/Category.hh>  
#include <log4cpp/PropertyConfigurator.hh>  
#include <log4cpp/NDC.hh>  
#include <log4cpp/FileAppender.hh>  
#include <log4cpp/BasicLayout.hh>  
log4cpp::Layout* layout = new log4cpp::BasicLayout();  
log4cpp::Appender* appender = new log4cpp::FileAppender("FileAppender", "./test_log4cpp1.log");  
appender->setLayout(layout);  
log4cpp::Category& warn_log = log4cpp::Category::getInstance("mywarn");  
warn_log.setAdditivity(false);  
warn_log.setAppender(appender);  
warn_log.setPriority(log4cpp::Priority::WARN);  
warn_log.critStream() << "This is a <Warn> log message..." << i;

看到上面的那些东西，真是令人望而生畏，我这才理解为什么之前看到的几个开源项目都是自己实现了一个日志类，好吧，cpp 程序员就是喜欢重复造轮子，术语叫什么来着，not invented here

好吧，既然求开源而不得，那只能自己动手丰衣足食了，总的来说，我们希望这个日志模块满足以下几个特点：

易用，最好是只要 include 一个头文件，然后就可以用了，退一步，我们可以接受在使用之前调用一次 init 函数，不需要另外编译依赖库，更不要安装。
轻量，对业务的能耗尽量减少到最小。
实现简洁。用尽量少的代码实现。
线程安全。
输出层级可控。
异步落地磁盘，而且按照文件大小或者时间自动滚动。

而最终的效果，使用上，我们希望是这样的用法。

init_log();
LOG_DEBUG("test log %d", 123);
LOG_ERR("test err %s", "456");

这个地方，之所以用 c 的转义，而不用 cpp 的流式，一个是考虑到效率，一个是考虑到现有的代码兼容。

首先上来遇到的第一个问题，我们需要打印行号，文件名，函数名等等，这些怎么得到呢，想到用宏，__LINE__，__FILE__，等等，但是，宏展开之后，需要调用我们自己的函数吧，这些可变参数怎么从我们的函数传到 printf 呢？

在这个地方纠结了很久，一开始去找各种 va_list 的传递方法，发现这个几乎是不可能的，于是后面又找了 vsnprintf 这种的函数，才发现有这么一类可以直接接收 va_list 的函数存在。

然后就是日志类的初始化问题，一开始，想到用类的静态函数来做，但是又发现，这样的话，也是有问题的，于是后面用单例来做。

然后就是异步的问题，这个是想到先把日志存到内存，然后用线程异步写入磁盘文件。但是遇到问题是，内存要怎么布局呢，如果我们把内存连续的用起来，那么，多个线程同时写的时候，怎么解决字符串交错的问题呢，如果用锁，那么性能必然大大下降。

另外的一个问题是，我们申请一片定长内存，然后把它当作循环队列来用，但是，在快到结尾的时候，例如，假如还剩下 50 个字符的空间，但是有一条日志过来了，而这个日志要占用 100 个字符，那怎么处理剩下的 50 个呢，按照循环队列的意义，应该转到头部继续写的，但是，到时候怎么打印出来呢。如果不截断的话，有什么办法解决呢。而且更麻烦的问题是，在一个字符串被格式化完成之前，我们是不知道这个字符串会有多长的。

对于这个问题，有一个办法是，我们留下一部分内存空间，当作保留区，例如，我们申请 15M，但是只有 14M 是拿来当循环队列的，那么，当指针超过 14 的时候，下一条就回来开始的地方了，这样的话，就要限定，刚好在 14 M 边缘的那条，单行不能超过 1MB，这个限制，应该还是可以接受的。

但是依然没有解决多线程的并发写入问题。

这个问题，或许用一个二维的字符型数组来实现，然后用下标的原子操作来避免多线程混叠，但是，这样的话，我们就需要按照最长的可能单行来分配，那么，就必然造成大量的空间浪费，特别是在最长的单行比大多数的单行都长很多倍的情况下。

待续。

历史评论

wanax (2013-09-23 15:36:44):

iphone开发下面有个开源日志还可以打印图片的….客户端输出还不是控制台碉堡了

ZRJ (2013-09-23 18:49:18):

堂堂 c++ 一大帮人在用，居然连个日志标准都没有。。

cc 和 cpp 混合情况的 makefile

Thu, 29 Aug 2013 20:31:44 +0800

今天需要写一个 makefile，项目里面有 pb 生成的 cc 和 cpp 文件，分别要生成各自的 obj，以前没有遇到过这种 cc 和 cpp 混合的情况，上网找了一下，找到这个模版，http://lcinx.blog.163.com/blog/static/434942672010913291210/：

#
# c.cpp混合编译的makefile模板
#
#


BIN = test.exe
CC = gcc
CPP = g++
#这里只加入库头文件路径及库路径
INCS = -I"c:/mingw/include"
LIBS = -L"c:/mingw/lib"
SUBDIRS =
#生成依赖信息时的搜索目录，比如到下列目录中搜索一个依赖文件(比如.h文件)，例如 -I"./***/" -I"./base/"
DEFINC =
#给INCS加上依赖搜索路径，分开写可能会产生不一致情况，而且繁琐
INCS += $(DEFINC)
#
#
#maintest.c tree/rbtree.c  多了子目录，那就直接添加 目录/*.c即可   所有的源文件--  .c文件列表
CSRCS = $(wildcard ./*.c)
CPPSRCS = $(wildcard ./*.cpp)
#SRCS += $(wildcard ./../base/*.c)
#SRCS += $(wildcard ./*.c ./src/*.c ./src/base/*.c ./src/base/tree/*.c ./src/mem/*.c)

#
#
#所有的.o文件列表
COBJS := $(CSRCS:.c=.o)
CPPOBJS := $(CPPSRCS:.cpp=.o)
#
#生成依赖信息 -MM是只生成自己的头文件信息，-M 包含了标准库头文件信息。
#-MT 或 -MQ都可以改变生成的依赖  xxx.o:src/xxx.h 为 src/xxx.o:src/xxx.h 当然。前面的 src/xxx.o需自己指定
#格式为 -MM 输入.c或.cpp  查找依赖路径  -MT或-MQ  生成规则，比如src/xxx.o 
MAKEDEPEND = gcc -MM -MT
CFLAGS += $(INCS)
CFLAGS += -O2 -Wall -fomit-frame-pointer -g -ansi
CPPFLAGS += $(INCS)
CPPFLAGS += -O2 -Wall -g
#-g 生成调试信息
#-pedantic参数与-ansi一起使用 会自动拒绝编译非ANSI程序
#-fomit-frame-pointer 去除函数框架
#-Wmissing-prototypes -Wstrict-prototypes 检查函数原型
#针对每个.c文件的.d依赖文件列表
CDEF = $(CSRCS:.c=.d)
CPPDEF = $(CPPSRCS:.cpp=.d)

all:$(BIN)

#生成.o的对自己目录中.h .c的依赖信息.d文件到.c所在的路径中
#$(DEF)文件是.d文件名列表(含目录)，比如tree.d 匹配成功那么%就是tree，然后在尝试%.c，如果成功。则执行规则
# $(<:.c=.o)是获取此.c文件的名字(含路径)，然后变为.o比如 src/xxx.o。 以形成如下
# src/xxx.o : src/xxx.c ***.h  ***.h  最前面！！注意。  
# 此做法是每个.d都和生成他的.c在一个目录里，所以需要这样做。
# $(<:.c=.o)之类的 。此时的<相当于变量$< 。切记
# : : :  含义同下
$(CDEF) : %.d : %.c
    $(MAKEDEPEND) $(<:.c=.o) $< $(DEFINC) > $@
$(CPPDEF) : %.d : %.cpp
    $(MAKEDEPEND) $(<:.cpp=.o) $< $(DEFINC) > $@

#先删除依赖信息
#重新生成依赖信息
#这里出现了一个 $(MAKE) 没有定义的变量。这个变量是由 Make 自己定义的，它的值即为自己的位置，方便 Make 递归调用自己。
depend:
    rm $(CDEF)
    rm $(CPPDEF)
    $(MAKE) $(CDEF)
    $(MAKE) $(CPPDEF)

#$(OBJS):%.o :%.c  先用$(OBJS)中的一项，比如foo.o: %.o : %.c  含义为:试着用%.o匹配foo.o。如果成功%就等于foo。如果不成功，
# Make就会警告，然后。给foo.o添加依赖文件foo.c(用foo替换了%.c里的%)
# 也可以不要下面的这个生成规则，因为下面的 include $(DEF)  就隐含了。此处为了明了，易懂。故留着
$(COBJS) : %.o: %.c
    $(CC) -c $< -o $@ $(CFLAGS)
$(CPPOBJS) : %.o: %.cpp
    $(CPP) -c $< -o $@ $(CPPFLAGS)

# $@--目标文件，$^--所有的依赖文件，$<--第一个依赖文件。每次$< $@ 代表的值就是列表中的
#
$(BIN) : $(COBJS) $(CPPOBJS)
    $(CC) -o $(BIN) $(COBJS) $(CPPOBJS) $(LIBS)
    rm $(COBJS)
    rm $(CPPOBJS)
    rm $(CDEF)
    rm $(CPPDEF)
# 链接为最终目标


#引入了.o文件对.c和.h的依赖情况。以后.h被修改也会重新生成，可看看.d文件内容即知道为何
#引入了依赖就相当于引入了一系列的规则，因为依赖内容例如： 目录/xxx.o:目录/xxx.c 目录/xxx.h 也相当于隐含的引入了生成规则
#故上面不能在出现如： $(OBJS) : $(DEF)之类。切记
include $(CDEF)
include $(CPPDEF)
.PHONY:clean cleanall

#清除所有目标文件以及生成的最终目标文件
clean:            
    rm $(BIN) $(COBJS) $(CPPOBJS)
#rm *.d
cleanall:
    rm $(CDEF) $(CPPDEF)
    rm $(BIN) $(COBJS) $(CPPOBJS)

但是其实我写的东西不用这么复杂，本着能少写一个字母就少写一个字母的原则，我最终的 makefile 如下：

BIN = GenPbPerfTest

CXX = g++
CXX_FLAGS = -g -Wall -DDEBUG
LIBS = -lprotobuf
INCS =

CC_SRCS = $(wildcard *.cc)
CPP_SRCS = $(wildcard *.cpp)

CC_OBJS = $(patsubst %.cc,%.o, $(CC_SRCS))
CPP_OBJS = $(patsubst %.cpp,%.o, $(CPP_SRCS))
OBJS = $(CC_OBJS) $(CPP_OBJS)

all : $(BIN)

$(BIN) : $(OBJS)
	$(CXX) $(CXX_FLAGS) $(LIBS) -o $@ $^
    
$(CC_OBJS) : %.o : %.cc
	$(CXX) $(CXX_FLAGS) $(INCS) -c $<
    
$(CPP_OBJS) : %.o : %.cpp
	$(CXX) $(CXX_FLAGS) $(INCS) -c $<
    
.PHONY : clean
clean:
	rm -f *.o $(BIN)

功能没有那么强大，最大的缺失是对于 h 文件的依赖关系没有考虑进来，不过也够用了，实在不行就 make clean && make 一下嘛，哈哈

=================================================

2013-08-29 20:34:48

BIN = GenPbPerfTest

CXX = g++
CXX_FLAGS = -g -Wall -DDEBUG
LIBS = -lprotobuf
INCS =

CC_SRCS = $(wildcard *.cc)
CPP_SRCS = $(wildcard *.cpp)

CC_OBJS := $(CC_SRCS:.cc=.o)
CPP_OBJS := $(CPP_SRCS:.cpp=.o)
OBJS = $(CC_OBJS) $(CPP_OBJS)

all : $(BIN)

$(BIN) : $(OBJS)
	$(CXX) $(CXX_FLAGS) $(LIBS) -o $@ $^
    
$(CC_OBJS) : %.o : %.cc
	$(CXX) $(CXX_FLAGS) $(INCS) -c $<
    
$(CPP_OBJS) : %.o : %.cpp
	$(CXX) $(CXX_FLAGS) $(INCS) -c $<
    
.PHONY : clean
clean:
	rm -f *.o $(BIN)

后来发现可以少写几个字母，改动在 11 12 行

=========================================================================

2013-08-29 20:37:25 买一送一，http://www.sf.org.cn/Article/base/200701/19975.html，这里有个通用的

###############################################################################
#
# Generic Makefile for C/C++ Program
#
# Author: whyglinux (whyglinux AT hotmail DOT com)
# Date: 2006/03/04

# Description:
# The makefile searches in directories for the source files
# with extensions specified in , then compiles the sources
# and finally produces the , the executable file, by linking
# the objectives.

# Usage:
# $ make compile and link the program.
# $ make objs compile only (no linking. Rarely used).
# $ make clean clean the objectives and dependencies.
# $ make cleanall clean the objectives, dependencies and executable.
# $ make rebuild rebuild the program. The same as make clean && make all.
#==============================================================================

## Customizing Section: adjust the following if necessary.
##=============================================================================

# The executable file name.
# It must be specified.
# PROGRAM := a.out # the executable name
PROGRAM :=

# The directories in which source files reside.
# At least one path should be specified.
# SRCDIRS := . # current directory
SRCDIRS :=

# The source file types (headers excluded).
# At least one type should be specified.
# The valid suffixes are among of .c, .C, .cc, .cpp, .CPP, .c++, .cp, or .cxx.
# SRCEXTS := .c # C program
# SRCEXTS := .cpp # C++ program
# SRCEXTS := .c .cpp # C/C++ program
SRCEXTS :=

# The flags used by the cpp (man cpp for more).
# CPPFLAGS := -Wall -Werror # show all warnings and take them as errors
CPPFLAGS :=

# The compiling flags used only for C.
# If it is a C++ program, no need to set these flags.
# If it is a C and C++ merging program, set these flags for the C parts.
CFLAGS :=
CFLAGS +=

# The compiling flags used only for C++.
# If it is a C program, no need to set these flags.
# If it is a C and C++ merging program, set these flags for the C++ parts.
CXXFLAGS :=
CXXFLAGS +=

# The library and the link options ( C and C++ common).
LDFLAGS :=
LDFLAGS +=

## Implict Section: change the following only when necessary.
##=============================================================================
# The C program compiler. Uncomment it to specify yours explicitly.
#CC = gcc

# The C++ program compiler. Uncomment it to specify yours explicitly.
#CXX = g++

# Uncomment the 2 lines to compile C programs as C++ ones.
#CC = $(CXX)
#CFLAGS = $(CXXFLAGS)

# The command used to delete file.
#RM = rm -f

## Stable Section: usually no need to be changed. But you can add more.
##=============================================================================
SHELL = /bin/sh
SOURCES = $(foreach d,$(SRCDIRS),$(wildcard $(addprefix $(d)/*,$(SRCEXTS))))
OBJS = $(foreach x,$(SRCEXTS), \
$(patsubst %$(x),%.o,$(filter %$(x),$(SOURCES))))
DEPS = $(patsubst %.o,%.d,$(OBJS))

.PHONY : all objs clean cleanall rebuild

all : $(PROGRAM)

# Rules for creating the dependency files (.d).
#---------------------------------------------------
%.d : %.c
@$(CC) -MM -MD $(CFLAGS) $<

%.d : %.C
@$(CC) -MM -MD $(CXXFLAGS) $<

%.d : %.cc
@$(CC) -MM -MD $(CXXFLAGS) $<

%.d : %.cpp
@$(CC) -MM -MD $(CXXFLAGS) $<

%.d : %.CPP
@$(CC) -MM -MD $(CXXFLAGS) $<

%.d : %.c++
@$(CC) -MM -MD $(CXXFLAGS) $<

%.d : %.cp
@$(CC) -MM -MD $(CXXFLAGS) $<

%.d : %.cxx
@$(CC) -MM -MD $(CXXFLAGS) $<

# Rules for producing the objects.
#---------------------------------------------------
objs : $(OBJS)

%.o : %.c
$(CC) -c $(CPPFLAGS) $(CFLAGS) $<

%.o : %.C
$(CXX) -c $(CPPFLAGS) $(CXXFLAGS) $<

%.o : %.cc
$(CXX) -c $(CPPFLAGS) $(CXXFLAGS) $<

%.o : %.cpp
$(CXX) -c $(CPPFLAGS) $(CXXFLAGS) $<

%.o : %.CPP
$(CXX) -c $(CPPFLAGS) $(CXXFLAGS) $<

%.o : %.c++
$(CXX -c $(CPPFLAGS) $(CXXFLAGS) $<

%.o : %.cp
$(CXX) -c $(CPPFLAGS) $(CXXFLAGS) $<

%.o : %.cxx
$(CXX) -c $(CPPFLAGS) $(CXXFLAGS) $<

# Rules for producing the executable.
#----------------------------------------------
$(PROGRAM) : $(OBJS)
ifeq ($(strip $(SRCEXTS)), .c) # C file
$(CC) -o $(PROGRAM) $(OBJS) $(LDFLAGS)
else # C++ file
$(CXX) -o $(PROGRAM) $(OBJS) $(LDFLAGS)
endif

-include $(DEPS)

rebuild: clean all

clean :
@$(RM) *.o *.d

cleanall: clean
@$(RM) $(PROGRAM) $(PROGRAM).exe

### End of the Makefile ## Suggestions are welcome ## All rights reserved ###
###############################################################################

下面是引用原文

C/C++ 通用 Makefile Generic Makefile for C/C++ Program

================================================== Keywords: Makefile, make, Generic, C/C++ Author: whyglinux (whyglinux AT hotmail DOT com) Date: 2006-03-04 ==================================================

本文提供了一个用于对 C/C++ 程序进行编译和连接以产生可执行程序的通用 Makefile。

在使用 Makefile 之前，只需对它进行一些简单的设置即可；而且一经设置，即使以后对源程序文件有所增减一般也不再需要改动 Makefile。因此，即便是一个没有学习过 Makefile 书写规则的人，也可以为自己的 C/C++ 程序快速建立一个可工作的 Makefile。

这个 Makefile 可以在 GNU Make 和 GCC 编译器下正常工作。但是不能保证对于其它版本的 Make 和编译器也能正常工作。

如果你发现了本文中的错误，或者对本文有什么感想或建议，可通过 whyglinux AT hotmail DOT com 邮箱和作者联系。

此 Makefile 的使用方法如下：

1. 程序目录的组织尽量将自己的源程序集中在一个目录中，并且把 Makefile 和源程序放在一起，这样用起来比较方便。当然，也可以将源程序分类存放在不同的目录中。

在程序目录中创建一个名为 Makefile 的文本文件，将后面列出的 Makefile 的内容复制到这个文件中。（注意：在复制的过程中，Makfile 中各命令前面的 Tab 字符有可能被转换成若干个空格。这种情况下需要把 Makefile 命令前面的这些空格替换为一个 Tab。）

将当前工作目录切换到 Makefile 所在的目录。目前，这个 Makefile 只支持在当前目录中的调用，不支持当前目录和 Makefile 所在的路径不是同一目录的情况。

2. 指定可执行文件程序编译和连接成功后产生的可执行文件在 Makefile 中的 PROGRAM 变量中设定。这一项不能为空。为自己程序的可执行文件起一个有意义的名子吧。

3. 指定源程序要编译的源程序由其所在的路径和文件的扩展名两项来确定。由于头文件是通过包含来使用的，所以在这里说的源程序不应包含头文件。

程序所在的路径在 SRCDIRS 中设定。如果源程序分布在不同的目录中，那么需要在 SRCDIRS 中一一指定，并且路径名之间用空格分隔。

在 SRCEXTS 中指定程序中使用的文件类型。C/C++ 程序的扩展名一般有比较固定的几种形式：.c、.C、.cc、.cpp、.CPP、.c++、.cp、或者.cxx（参见 man gcc）。扩展名决定了程序是 C 还是 C++ 程序：.c 是 C 程序，其它扩展名表示 C++ 程序。一般固定使用其中的一种扩展名即可。但是也有可能需要使用多种扩展名，这可以在 SOURCE_EXT 中一一指定，各个扩展名之间用空格分隔。

虽然并不常用，但是 C 程序也可以被作为 C++ 程序编译。这可以通过在 Makefile 中设置 CC = $(CXX) 和 CFLAGS = $(CXXFLAGS) 两项即可实现。

这个 Makefile 支持 C、C++ 以及 C/C++ 混合三种编译方式： * 如果只指定 .c 扩展名，那么这是一个 C 程序，用 $(CC) 表示的编译命令进行编译和连接。 * 如果指定的是除 .c 之外的其它扩展名（如 .cc、.cpp、.cxx 等），那么这是一个 C++ 程序，用 $(CXX) 进行编译和连接。 * 如果既指定了 .c，又指定了其它 C++ 扩展名，那么这是 C/C++ 混合程序，将用 $(CC) 编译其中的 C 程序，用 $(CXX) 编译其中的 C++ 程序，最后再用 $(CXX) 连接程序。

这些工作都是 make 根据在 Makefile 中提供的程序文件类型（扩展名）自动判断进行的，不需要用户干预。

# 指定编译选项编译选项由三部分组成：预处理选项、编译选项以及连接选项，分别由 CPPFLAGS、CFLAGS与CXXFLAGS、LDFLAGS 指定。

CPPFLAGS 选项可参考 C 预处理命令 cpp 的说明，但是注意不能包含 -M 以及和 -M 有关的选项。如果是 C/C++ 混合编程，也可以在这里设置 C/C++ 的一些共同的编译选项。

CFLAGS 和 CXXFLAGS 两个变量通常用来指定编译选项。前者仅仅用于指定 C 程序的编译选项，后者仅仅用于指定 C++ 程序的编译选项。其实也可以在两个变量中指定一些预处理选项（即一些本来应该放在 CPPFLAGS 中的选项），和 CPPFLAGS 并没有明确的界限。

连接选项在 LDFLAGS 中指定。如果只使用 C/C++ 标准库，一般没有必要设置。如果使用了非标准库，应该在这里指定连接需要的选项，如库所在的路径、库名以及其它联接选项。

现在的库一般都提供了一个相应的 .pc 文件来记录使用库所需要的预编译选项、编译选项和连接选项等信息，通过 pkg-config 可以动态提取这些选项。与由用户显式指定各个选项相比，使用 pkg-config 来访问库提供的选项更方便、更具通用性。在后面可以看到一个 GTK+ 程序的例子，其编译和连接选项的指定就是用 pkg-config 实现的。

# 编译和连接上面的各项设置好之后保存 Makefile 文件。执行 make 命令，程序就开始编译了。

命令 make 会根据 Makefile 中设置好的路径和文件类型搜索源程序文件，然后根据文件的类型调用相应的编译命令、使用相应的编译选项对程序进行编译。

编译成功之后程序的连接会自动进行。如果没有错误的话最终会产生程序的可执行文件。

注意：在对程序编译之后，会产生和源程序文件一一对应的 .d 文件。这是表示依赖关系的文件，通过它们 make 决定在源程序文件变动之后要进行哪些更新。为每一个源程序文件建立相应的 .d 文件这也是 GNU Make 推荐的方式。

# Makefile 目标（Targets）下面是关于这个 Makefile 提供的目标以及它所完成的功能：

* make 编译和连接程序。相当于 make all。 * make objs 仅仅编译程序产生 .o 目标文件，不进行连接（一般很少单独使用）。 * make clean 删除编译产生的目标文件和依赖文件。 * make cleanall 删除目标文件、依赖文件以及可执行文件。 * make rebuild 重新编译和连接程序。相当于 make clean && make all。

关于这个 Makefile 的实现原理不准备详细解释了。如果有兴趣的话，可参考文末列出的“参考资料”。

Makefile 的内容如下：

############################################################################### # # Generic Makefile for C/C++ Program # # Author: whyglinux (whyglinux AT hotmail DOT com) # Date: 2006/03/04

# Description: # The makefile searches in directories for the source files # with extensions specified in , then compiles the sources # and finally produces the , the executable file, by linking # the objectives.

# Usage: # $ make compile and link the program. # $ make objs compile only (no linking. Rarely used). # $ make clean clean the objectives and dependencies. # $ make cleanall clean the objectives, dependencies and executable. # $ make rebuild rebuild the program. The same as make clean && make all. #==============================================================================

## Customizing Section: adjust the following if necessary. ##=============================================================================

# The executable file name. # It must be specified. # PROGRAM := a.out # the executable name PROGRAM :=

# The directories in which source files reside. # At least one path should be specified. # SRCDIRS := . # current directory SRCDIRS :=

# The source file types (headers excluded). # At least one type should be specified. # The valid suffixes are among of .c, .C, .cc, .cpp, .CPP, .c++, .cp, or .cxx. # SRCEXTS := .c # C program # SRCEXTS := .cpp # C++ program # SRCEXTS := .c .cpp # C/C++ program SRCEXTS :=

# The flags used by the cpp (man cpp for more). # CPPFLAGS := -Wall -Werror # show all warnings and take them as errors CPPFLAGS :=

# The compiling flags used only for C. # If it is a C++ program, no need to set these flags. # If it is a C and C++ merging program, set these flags for the C parts. CFLAGS := CFLAGS +=

# The compiling flags used only for C++. # If it is a C program, no need to set these flags. # If it is a C and C++ merging program, set these flags for the C++ parts. CXXFLAGS := CXXFLAGS +=

# The library and the link options ( C and C++ common). LDFLAGS := LDFLAGS +=

## Implict Section: change the following only when necessary. ##============================================================================= # The C program compiler. Uncomment it to specify yours explicitly. #CC = gcc

# The C++ program compiler. Uncomment it to specify yours explicitly. #CXX = g++

# Uncomment the 2 lines to compile C programs as C++ ones. #CC = $(CXX) #CFLAGS = $(CXXFLAGS)

# The command used to delete file. #RM = rm -f

## Stable Section: usually no need to be changed. But you can add more. ##============================================================================= SHELL = /bin/sh SOURCES = $(foreach d,$(SRCDIRS),$(wildcard $(addprefix $(d)/*,$(SRCEXTS)))) OBJS = $(foreach x,$(SRCEXTS), \ $(patsubst %$(x),%.o,$(filter %$(x),$(SOURCES)))) DEPS = $(patsubst %.o,%.d,$(OBJS))

.PHONY : all objs clean cleanall rebuild

all : $(PROGRAM)

# Rules for creating the dependency files (.d). #————————————————— %.d : %.c @$(CC) -MM -MD $(CFLAGS) $<

%.d : %.C @$(CC) -MM -MD $(CXXFLAGS) $<

%.d : %.cc @$(CC) -MM -MD $(CXXFLAGS) $<

%.d : %.cpp @$(CC) -MM -MD $(CXXFLAGS) $<

%.d : %.CPP @$(CC) -MM -MD $(CXXFLAGS) $<

%.d : %.c++ @$(CC) -MM -MD $(CXXFLAGS) $<

%.d : %.cp @$(CC) -MM -MD $(CXXFLAGS) $<

%.d : %.cxx @$(CC) -MM -MD $(CXXFLAGS) $<

# Rules for producing the objects. #————————————————— objs : $(OBJS)

%.o : %.c $(CC) -c $(CPPFLAGS) $(CFLAGS) $<

%.o : %.C $(CXX) -c $(CPPFLAGS) $(CXXFLAGS) $<

%.o : %.cc $(CXX) -c $(CPPFLAGS) $(CXXFLAGS) $<

%.o : %.cpp $(CXX) -c $(CPPFLAGS) $(CXXFLAGS) $<

%.o : %.CPP $(CXX) -c $(CPPFLAGS) $(CXXFLAGS) $<

%.o : %.c++ $(CXX -c $(CPPFLAGS) $(CXXFLAGS) $<

%.o : %.cp $(CXX) -c $(CPPFLAGS) $(CXXFLAGS) $<

%.o : %.cxx $(CXX) -c $(CPPFLAGS) $(CXXFLAGS) $<

# Rules for producing the executable. #———————————————- $(PROGRAM) : $(OBJS) ifeq ($(strip $(SRCEXTS)), .c) # C file $(CC) -o $(PROGRAM) $(OBJS) $(LDFLAGS) else # C++ file $(CXX) -o $(PROGRAM) $(OBJS) $(LDFLAGS) endif

-include $(DEPS)

rebuild: clean all

clean : @$(RM) *.o *.d

cleanall: clean @$(RM) $(PROGRAM) $(PROGRAM).exe

### End of the Makefile ## Suggestions are welcome ## All rights reserved ### ###############################################################################

下面提供两个例子来具体说明上面 Makefile 的用法。

例一　Hello World 程序

这个程序的功能是输出 Hello, world! 这样一行文字。由 hello.h、hello.c、main.cxx 三个文件组成。前两个文件是 C 程序，后一个是 C++ 程序，因此这是一个 C 和 C++ 混编程序。

/* File name: hello.h * C header file */

#ifndef HELLO_H #define HELLO_H

#ifdef __cplusplus extern “C” { #endif

void print_hello();

#ifdef __cplusplus } #endif

#endif

/* File name: hello.c * C source file. */ #include “hello.h” #include

void print_hello() { puts( “Hello, world!” ); }

/* File name: main.cxx * C++ source file. */ #include “hello.h”

int main() { print_hello();

return 0; }

建立一个新的目录，然后把这三个文件拷贝到目录中，也把 Makefile 文件拷贝到目录中。之后，对 Makefile 的相关项目进行如下设置：

PROGRAM := hello # 设置运行程序名 SRCDIRS := . # 源程序位于当前目录下 SRCEXTS := .c .cxx # 源程序文件有 .c 和 .cxx 两种类型 CFLAGS := -g # 为 C 目标程序包含 GDB 可用的调试信息 CXXFLAGS := -g # 为 C++ 目标程序包含 GDB 可用的调试信息

由于这个简单的程序只使用了 C 标准库的函数（puts），所以对于 CFLAGS 和 CXXFLAGS 没有过多的要求，LDFLAGS 和 CPPFLAGS 选项也无需设置。

经过上面的设置之后，执行 make 命令就可以编译程序了。如果没有错误出现的话，./hello 就可以运行程序了。

如果修改了源程序的话，可以看到只有和修改有关的源文件被编译。也可以再为程序添加新的源文件，只要它们的扩展名是已经在 Makefile 中设置过的，那么就没有必要修改　Makefile。

例二　GTK+ 版 Hello World 程序

这个 GTK+ 2.0 版的 Hello World 程序可以从下面的网址上得到：http://www.gtk.org/tutorial/c58.html#SEC-HELLOWORLD。当然，要编译 GTK+ 程序，还需要你的系统上已经安装好了 GTK+。

跟第一个例子一样，单独创建一个新的目录，把上面网页中提供的程序保存为 main.c 文件。对 Makefile 做如下设置：

PROGRAM := hello # 设置运行程序名 SRCDIRS := . # 源程序位于当前目录下 SRCEXTS := .c # 源程序文件只有 .c 一种类型 CFLAGS := `pkg-config –cflags gtk+-2.0` # CFLAGS LDFLAGS := `pkg-config –libs gtk+-2.0` # LDFLAGS

这是一个 C 程序，所以 CXXFLAGS 没有必要设置——即使被设置了也不会被使用。

编译和连接 GTK+ 库所需要的 CFLAGS 和 LDFLAGS 由 pkg-config 程序自动产生。

现在就可以运行 make 命令编译、./hello 执行这个 GTK+ 程序了。

Google perftools cpu profiler 对多进程的支持问题

Wed, 28 Aug 2013 11:05:48 +0800

折腾了好久，到目前还是没有让 gperftools cpu profiler 能在多进程环境下跑起来，问题如下：

main_cmd_argv.cpp

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <gperftools/profiler.h>

int loop(int n) {
    int sum = 0;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            sum = i + j;
            if (sum %3 == 0) {
                sum /= 3;
            }
        }
    }
    return 0;
}

int main(int argc, char* argv[]) {

    printf("%s\n%s\n", getenv("CPUPROFILE"), getenv("CPUPROFILESIGNAL"));

    if (argc > 1 && strcmp(argv[1], "-s")==0) {
        // single process
        loop(100000);
        printf("stoped\n");
    } else if (argc > 1 && strcmp(argv[1], "-m")==0) {
        // multi process
        pid_t pid = fork();
        if (pid < 0) {
            printf("fork error\n");
            return -1;
        }
        if (pid == 0) {    
            loop(100000);
            printf("child stoped\n");
        } else if (pid > 0) {
            loop(10000);
            printf("father stoped\n");
            wait(NULL);
        }        
    }   

    return 0;
}

makefile

GPerfTools=/home/adenzhang/tools/gperftools

CCFLAGS=-fno-omit-frame-pointer -g -Wall

ALL_BINS=main_cmd_argv
all:$(ALL_BINS)

main_cmd_argv:main_cmd_argv.o
    g++ $(CCFLAGS) -o $@ $^ -L./ -L$(GPerfTools)/lib -Wl,-Bdynamic -lprofiler -lunwind

.cpp.o:
    g++ $(CCFLAGS) -c -I./ -I$(GPerfTools)/include -fPIC -o $@ $<
clean:
    rm -f $(ALL_BINS) *.o *.prof

运行过程

$ make
g++ -fno-omit-frame-pointer -g -Wall -c -I./ -I/home/adenzhang/tools/gperftools/include -fPIC -o main_cmd_argv.o main_cmd_argv.cpp
g++ -fno-omit-frame-pointer -g -Wall -o main_cmd_argv main_cmd_argv.o -L./ -L/home/adenzhang/tools/gperftools/lib -Wl,-Bdynamic -lprofiler -lunwind
$ env CPUPROFILE=main_cmd_argv.prof ./main_cmd_argv -s
젩n_cmd_argv.prof
(null)
stoped
PROFILE: interrupts/evictions/bytes = 6686/3564/228416
$ /home/adenzhang/tools/gperftools/bin/pprof --text ./main_cmd_argv ./main_cmd_argv.prof 
Using local file ./main_cmd_argv.
Using local file ./main_cmd_argv.prof.
Removing killpg from all stack traces.
Total: 6686 samples
    6686 100.0% 100.0%     6686 100.0% loop
       0   0.0% 100.0%     6686 100.0% __libc_start_main
       0   0.0% 100.0%     6686 100.0% _start
       0   0.0% 100.0%     6686 100.0% main
$ rm main_cmd_argv.prof 
$ env CPUPROFILE=main_cmd_argv.prof ./main_cmd_argv -m
젩n_cmd_argv.prof
(null)
father stoped
child stoped
PROFILE: interrupts/evictions/bytes = 0/0/64
PROFILE: interrupts/evictions/bytes = 68/36/2624
$ ls 
main_cmd_argv  main_cmd_argv.cpp  main_cmd_argv.o  main_cmd_argv.prof  Makefile
$ /home/adenzhang/tools/gperftools/bin/pprof --text ./main_cmd_argv ./main_cmd_argv.prof 
Using local file ./main_cmd_argv.
Using local file ./main_cmd_argv.prof.
$

先记下来吧，后面再想办法搞。

小广告贴的到处都是：http://stackoverflow.com/questions/18384760/gperftools-cpu-profiler-does-not-support-multi-process，https://groups.google.com/forum/#!topic/google-perftools/bmysZILR4ik，http://www.searchtb.com/2012/12/google-cpu-profiler.html，https://code.google.com/p/gperftools/issues/detail?id=569&can=1&q=multi%20process

另外有一个讲性能分析的 stackoverflow 问答，顺便记下来：http://stackoverflow.com/questions/375913/what-can-i-use-to-profile-c-code-in-linux/378024#378024

历史评论

ZRJ (2013-10-15 08:54:18):

最后的结果是这样的：

Aliaksey Kandratsenka alkondratenko@gmail.com 9月9日

发送至 google-perftoo. It looks like profiler sets up timer for main thread early and then fork (which creates new thread) does not inherit this. I’m not very familiar with that code but I find it weird.

Anyways I was able to enable profiling in child by calling ProfilerRegisterThread right after ProfilerStart. Which set up profiling signal for child and made it work.

动态链接库中的全局变量 | ZRJ (2015-03-27 11:35:46):

[…] 考虑到之前做函数耗时测试，和代码覆盖度测试的时候，遇到过由于进程关系复杂（又多进程又线程的）引起的问题，考虑是否由于这个原因引起的问题，于是写了这么一个测试 […]

GCC "-fomit-frame-pointer"编译选项的含义

Thu, 22 Aug 2013 15:52:18 +0800

在 makefile 中看到这个编译选项，不太理解于是查了一下，相关的东西还不多，抄一下放在这里

首先这个文章，http://blog.csdn.net/byzs/article/details/2220461，讲的不错，挺清晰的：

优化你的软件时，发觉"-fomit-frame-pointer"这个选项还是蛮有用的。

GCC手册上面这么说： Don’t keep the frame pointer in a register for functions that don’t need one. This avoids the instructions to save, set up and restore frame pointers; it also makes an extra register available in many functions. It also makes debugging impossible on some machines.

On some machines, such as the VAX, this flag has no effect, because the standard calling sequence automatically handles the frame pointer and nothing is saved by pretending it doesn’t exist. The machine-description macro “FRAME_POINTER_REQUIRED” controls whether a target machine supports this flag.

这里，引入了一个"frame pointer"的概念，什么是"stack frame pointer(SFP)“呢？

我们知道，backtrace是利用堆栈中的信息把函数调用关系层层遍历出来的，其中这里的堆栈信息就是SFP。一般情况下，每一个函数都包含一个堆栈边界指针，也就是说会存在一个栈底和栈顶指针。在X86下，假设堆栈由上往下发展，栈底大地址而栈顶小地址，那么，通常情况下，寄存器ESP为栈顶指针，而EBP就为栈底指针。而EBP和ESP之间的空间就是这个函数的stack frame。 GCC在默认情况下会在每个函数的开始加入一些堆栈设置代码，而在函数退出的时候恢复原来的样子，SFP就是在这个时候设置的。还是看一下这个时候的汇编代码吧 ;-)

环境：X86+Redhat 9.0，gcc 3.2.2

源文件如下：

$ cat test.c void a(unsigned long a, unsigned int b) { unsigned long i; unsigned int j;

        i = a; j = b;

        i++;

        j += 2;

}

默认编译选项： $ gcc -c test.c -o with_SFP.o

反汇编后是这个样子： $ objdump -D with_SFP.o

with_SFP.o:     file format elf32-i386

Disassembly of section .text:

00000000 : 0:   55                      push   %ebp 1:   89 e5                   mov    %esp,%ebp 3:   83 ec 08                sub    $0x8,%esp 6:   8b 45 08                mov    0x8(%ebp),%eax 9:   89 45 fc                mov    %eax,0xfffffffc(%ebp) c:   8b 45 0c                mov    0xc(%ebp),%eax f:   89 45 f8                mov    %eax,0xfffffff8(%ebp) 12:   8d 45 fc                lea    0xfffffffc(%ebp),%eax 15:   ff 00                   incl   (%eax) 17:   8d 45 f8                lea    0xfffffff8(%ebp),%eax 1a:   83 00 02                addl   $0x2,(%eax) 1d:   c9                      leave 1e:   c3                      ret Disassembly of section .data:

可以看到函数ENTER时首先把上一层函数的EBP入栈，设置本函数的EBP，然后会根据临时变量的数量和对齐要求去设置ESP，也就产生了函数的stack frame。我们再看看函数的返回：“leave"指令相当于"mov %ebp,%esp;pop %ebp”,也就是ENTER是两条指令的恢复过程，所以，后面的"ret"指令和"call"指令对应。这里backtrace就可以根据现有函数EBP指针得知上一个函数的EBP—-栈底再往上保存着上一个函数的EBP和EIP，然后就可以得知函数调用的路径。

SFP是可以在编译时候优化掉的，用”-fomit-frame-pointer"选项

编译： $ gcc -fomit-frame-pointer -c test.c -o no_SFP.o

$ objdump -D no_SFP.o

no_SFP.o:     file format elf32-i386

Disassembly of section .text:

00000000 : 0:   83 ec 08                sub    $0x8,%esp 3:   8b 44 24 0c             mov    0xc(%esp,1),%eax 7:   89 44 24 04             mov    %eax,0x4(%esp,1) b:   8b 44 24 10             mov    0x10(%esp,1),%eax f:   89 04 24                mov    %eax,(%esp,1) 12:   8d 44 24 04             lea    0x4(%esp,1),%eax 16:   ff 00                   incl   (%eax) 18:   89 e0                   mov    %esp,%eax 1a:   83 00 02                addl   $0x2,(%eax) 1d:   83 c4 08                add    $0x8,%esp 20:   c3                      ret Disassembly of section .data: 这里把EBP省掉了，ESP兼职了EBP的部分工作（索引临时变量）。显而易见，代码难懂了;-P，代码执行长度缩短了，应该能引起效率的提升。可恶的是，不能用backtrace调试了。

看一下arm下面的情况：含有SFP的版本： $ arm-linux-objdump -D SFP_arm.o

SFP_arm.o :     file format elf32-littlearm

Disassembly of section .text:

00000000 : 0:   e1a0c00d        mov     ip, sp 4:   e92dd800        stmdb   sp!, {fp, ip, lr, pc} 8:   e24cb004        sub     fp, ip, #4      ; 0x4 c:   e24dd010        sub     sp, sp, #16     ; 0x10 10:   e50b0010        str     r0, [fp, -#16] 14:   e50b1014        str     r1, [fp, -#20] 18:   e51b3010        ldr     r3, [fp, -#16] 1c:   e50b3018        str     r3, [fp, -#24] 20:   e51b3014        ldr     r3, [fp, -#20] 24:   e50b301c        str     r3, [fp, -#28] 28:   e51b3018        ldr     r3, [fp, -#24] 2c:   e2833001        add     r3, r3, #1      ; 0x1 30:   e50b3018        str     r3, [fp, -#24] 34:   e51b301c        ldr     r3, [fp, -#28] 38:   e2833002        add     r3, r3, #2      ; 0x2 3c:   e50b301c        str     r3, [fp, -#28] 40:   e91ba800        ldmdb   fp, {fp, sp, pc} Disassembly of section .data:

优化后的版本： $ arm-linux-objdump -D no_SFP_arm.o

no_SFP_arm.o:     file format elf32-littlearm

Disassembly of section .text:

00000000 : 0:   e24dd010        sub     sp, sp, #16     ; 0x10 4:   e58d000c        str     r0, [sp, #12] 8:   e58d1008        str     r1, [sp, #8] c:   e59d300c        ldr     r3, [sp, #12] 10:   e58d3004        str     r3, [sp, #4] 14:   e59d3008        ldr     r3, [sp, #8] 18:   e58d3000        str     r3, [sp] 1c:   e59d3004        ldr     r3, [sp, #4] 20:   e2833001        add     r3, r3, #1      ; 0x1 24:   e58d3004        str     r3, [sp, #4] 28:   e59d3000        ldr     r3, [sp] 2c:   e2833002        add     r3, r3, #2      ; 0x2 30:   e58d3000        str     r3, [sp] 34:   e28dd010        add     sp, sp, #16     ; 0x10 38:   e1a0f00e        mov     pc, lr Disassembly of section .data:

这里，“fp"充当了"EBP"的角色，ESP在X86里面被leave隐含的恢复好了，所以没有显示设置的必要。看起来arm平台上”-fomit-frame-pointer"选项的优化作用更加明显。

然后后面又看到这里，http://zhouzhen1.blogbus.com/logs/10843069.html，也讲到函数调用的压栈过程的 ebp，esp 指针的问题，但是感觉没太看懂：

今天下班前看了一下工作中涉及到的C++程序在VS.net环境中的编译选项。发现其中很多东西对我来说很陌生，公司的手册只是告诉我哪些要怎么设置，但并不提这个参数有什么意义，或者这样设的目的是什么。

刚才上网查了有关omit frame pointer的资料，

http://www.codeproject.com/tips/stackdumper.asp

我们说所谓函数调用反映在汇编层面表现为对栈的操作，而frame pointer指的是一个叫做ebp的寄存器，其中存放该函数的基址。发生函数调用时，调用者首先将函数变量以及返回地址入栈，而后代码指针转入被调用函数，这里首先将调用者的基址（已在调用者开始时存在ebp中）入栈，同时将自己的基址记入ebp，然后修改栈顶指针esp以容纳被调用函数自身的局部变量，函数退出时，将栈顶指针恢复至自己的基址（从ebp中取得），然后将调用者的基址弹出至ebp并返回。

所以说ebp用于记录函数的基址，用于在函数返回时的清栈工作。而在上面的链接中，作者提出利用这个处理过程的汇编代码来寻找栈操作汇编代码。

那么为什么VS.net可以忽略frame pointer？如果忽略的话，函数返回时岂不是不知道自己的基址了，怎么完成退栈呢？网上没人提这个，我想会不会是因为在编译过程中其实已经可以知道这个信息，所以直接把一个立即数赋给esp就可以了？

后面又看到这里，http://stackoverflow.com/questions/1942801/when-should-i-omit-the-frame-pointer，也讲到 ebp 可以减少栈操作：

-fomit-frame-pointer allows one extra register to be available for general-purpose use. I would assume this is really only a big deal on 32-bit x86, which is a bit starved for registers.*

One would expect to see EBP no longer saved and adjusted on every function call, and probably some additional use of EBP in normal code, and fewer stack operations on occasions where EBP gets used as a general-purpose register.

Your code is far too simple to see any benefit from this sort of optimization– you’re not using enough registers. Also, you haven’t turned on the optimizer, which might be necessary to see some of these effects.

* ISA registers, not micro-architecture registers.

而这里，http://stackoverflow.com/questions/14666665/trying-to-understand-gcc-option-fomit-frame-pointer，也讲到了，在简单的上下文环境中，这个选项其实是意义不大的：

Most smaller functions don’t need a frame-pointer - larger functions MAY need one.

It’s really about how well the compiler manages to track how the stack is used, and where things are on the stack (local variables, arguments passed to the current function and arguments being prepared for a function about to be called). I don’t think it’s easy to characterize the functions that need or don’t need a frame-pointer [technically, NO function HAS to have a frame-pointer - it’s more a case of “if the compiler deems it necessary to reduce the complexity of other code”].

I don’t think you should “attempt to make functions not have frame-pointer” as part of your strategy for coding - like I said, simple functions don’t need them, so use -fomit-frame-pointer, and you’ll get one more register available for the register allocator, and save 1-3 instructions on entry/exit to functions. If your function needs a frame-pointer, it’s because the compiler decides that’s a better option than using frame pointer. It’s not a goal to have functions without frame pointer, it’s a goal to have code that works both correctly and fast.

Note that “not having framepointer” should give better performance, but it’s not some magic bullet that gives enormous improvements - particularly not on x86-64, which already has 16 registers to start with. On 32-bit x86, since it only has 8 registers, one of which is stackpointer, and taking up another as the frame-pointer means 25% of register-space is taken. To change that to 12.5% is quite an improvement. Of course, compiling for 64-bit will help quite a lot too.

最后，gnu gcc 的文档这里，http://gcc.gnu.org/onlinedocs/gcc-3.4.4/gcc/Optimize-Options.html，讲到了这个选项的默认配置：

-fomit-frame-pointerDon’t keep the frame pointer in a register for functions that don’t need one. This avoids the instructions to save, set up and restore frame pointers; it also makes an extra register available in many functions. It also makes debugging impossible on some machines.

On some machines, such as the VAX, this flag has no effect, because the standard calling sequence automatically handles the frame pointer and nothing is saved by pretending it doesn’t exist. The machine-description macro FRAME_POINTER_REQUIRED controls whether a target machine supports this flag. See Register Usage.

Enabled at levels -O, -O2, -O3, -Os.

修改函数的返回地址

Wed, 21 Aug 2013 23:28:12 +0800

来看这个代码

#include <stdio.h>

void fun2() {
    printf("haha\n");
}

void fun1(int a) {
    int* ret_addr = (&a)-1;
    *ret_addr = (int)fun2;
}

int main() {
    int a = 3;
    fun1(a);
    return 0;
}

他跑起来之后的输出是这样的：

zrj@vm:~/tmp$ ./a.out 
haha
段错误 (核心已转储)

虽然触发了一个段错误，不过可以看到，还是成功的修改了函数的返回地址了的

其实之前是考虑用函数内部分配栈上变量来获得返回的地址的指针指向的，但是没有成功，可以看下这段代码

#include <stdio.h>

void fun2() {
    printf("haha\n");
}

void fun1(int a) {
    int b = 0;
    int* ret_addr = (&a)-1;
    printf("b+2: %p\nret_addr: %p\n", &b+2, ret_addr);
    *ret_addr = (int)fun2;
}

int main() {
    int a = 3;
    fun1(a);
    return 0;
}

输出如下：

zrj@vm:~/tmp$ ./a.out 
b+2: 0xbff136c0
ret_addr: 0xbff136cc
haha
段错误 (核心已转储)
zrj@vm:~/tmp$ cat main.cpp

可以看到栈上变量 b 和返回地址之间还是有不小的距离的，那么这中间是什么东西呢？还没搞清楚

linux smartctl

Sun, 21 Apr 2013 10:04:41 +0800

http://bbs.linuxtone.org/thread-1029-1-1.html

什么是S.M.A.R.T. SMART是一种磁盘自我分析检测技术，早在90年代末就基本得到了普及每一块硬盘（包括IDE、SCSI）在运行的时候，都会将自身的若干参数记录下来这些参数包括型号、容量、温度、密度、扇区、寻道时间、传输、误码率等硬盘运行了几千小时后，很多内在的物理参数都会发生变化某一参数超过报警阈值，则说明硬盘接近损坏此时硬盘依然在工作，如果用户不理睬这个报警继续使用那么硬盘将变得非常不可靠，随时可能故障

启用SMART SMART是和主板BIOS上相应功能配合的要使用SMART，必须先进入到主板BIOS设置里边启动相关设置一般从Pentium2级别起的主板，都支持SMART BIOS启动以后，就是操作系统级别的事情了很遗憾，Windows没有内置SMART相关工具（需要安装第三方工具软件）好在Linux上很早就有了SMART支持了如果把Linux装在VMware等虚拟机上，在系统启动时候可以看到有个服务启动报错：smartd 这个服务器就是smart的daemon进程（因为vmware虚拟机的硬盘不支持SMART，所以报错）

首先通过dmesg工具，确认一下硬盘的设备符号例如一个IDE硬盘连接到Primary IDE 总线上的Slave位置，硬盘设备符号是/dev/hdb hdb中的h代表IDE，如果显示为sdb，则代表SATA和SCSI 最后一个字幕b代表Primary总线，第二块硬盘即Slave位置

确认硬盘是否打开了SMART支持 smartctl -i /dev/hdb

例如看到如下返回结果 [root@3.6.0Biz-46 ~]# smartctl -i /dev/hdb smartctl version 5.33 [i386-redhat-linux-gnu] Copyright (C) 2002-4 Bruce Allen Home page is http://smartmontools.sourceforge.net/ === START OF INFORMATION SECTION === Device Model: ST380011A Serial Number: 3JVAPRGH Firmware Version: 3.04 User Capacity: 80,026,361,856 bytes Device is: In smartctl database [for details use: -P show] ATA Version is: 6 ATA Standard is: ATA/ATAPI-6 T13 1410D revision 2 Local Time is: Tue Apr 3 15:39:52 2007 CST SMART support is: Available - device has SMART capability. SMART support is: Disabled SMART Disabled. Use option -s with argument ‘on’ to enable it. [root@3.6.0Biz-46 ~]# 我们可以看到SMART support is: Disabled表示SMART未启用

执行如下命令，启动SMART： smartctl –smart=on –offlineauto=on –saveauto=on /dev/hdb

例如看到如下返回结果 [root@3.6.0Biz-46 ~]# smartctl –smart=on –offlineauto=on –saveauto=on /dev/hdb smartctl version 5.33 [i386-redhat-linux-gnu] Copyright (C) 2002-4 Bruce Allen Home page is http://smartmontools.sourceforge.net/ === START OF ENABLE/DISABLE COMMANDS SECTION === SMART Enabled. SMART Attribute Autosave Enabled. SMART Automatic Offline Testing Enabled every four hours. [root@3.6.0Biz-46 ~]# 现在硬盘的SMART功能已经被打开

执行如下命令查看硬盘的健康状况： smartctl -H /dev/hda 例如可以看到如下结果： [root@3.6.0Biz-46 ~]# smartctl -H /dev/hdb smartctl version 5.33 [i386-redhat-linux-gnu] Copyright (C) 2002-4 Bruce Allen Home page is http://smartmontools.sourceforge.net/ === START OF READ SMART DATA SECTION === SMART overall-health self-assessment test result: PASSED [root@3.6.0Biz-46 ~]# 请注意result后边的结果：PASSED，这表示硬盘健康状态良好如果这里显示Failure，那么最好立刻给服务器更换硬盘 SMART只能报告磁盘已经不再健康，但是报警后还能继续运行多久是不确定的通常，SMART报警参数是有预留的，磁盘报警后，不会当场坏掉，一般能坚持一段时间有的硬盘SMART报警后还继续跑了好几年，有的硬盘SMART报错后几天就坏了但是一旦出现报警，侥幸心里是万万不能的……

执行如下命令可以看到详细的参数： smartctl -A /dev/hdb 例如可以看到如下结果： [root@3.6.0Biz-46 ~]# smartctl -A /dev/hdb smartctl version 5.33 [i386-redhat-linux-gnu] Copyright (C) 2002-4 Bruce Allen Home page is http://smartmontools.sourceforge.net/ === START OF READ SMART DATA SECTION === SMART Attributes Data Structure revision number: 10 Vendor Specific SMART Attributes with Thresholds: ID# ATTRIBUTE_NAME FLAG VALUE WORST THRESH TYPE UPDATED WHEN_FAILED RAW_VALUE 1 Raw_Read_Error_Rate 0x000f 053 051 006 Pre-fail Always - 11338710 3 Spin_Up_Time 0x0003 098 097 000 Pre-fail Always - 0 4 Start_Stop_Count 0x0032 100 100 020 Old_age Always - 17 5 Reallocated_Sector_Ct 0x0033 100 100 036 Pre-fail Always - 0 7 Seek_Error_Rate 0x000f 087 060 030 Pre-fail Always - 610059516 9 Power_On_Hours 0x0032 087 087 000 Old_age Always - 11974 10 Spin_Retry_Count 0x0013 100 100 097 Pre-fail Always - 0 12 Power_Cycle_Count 0x0032 100 100 020 Old_age Always - 110 194 Temperature_Celsius 0x0022 045 052 000 Old_age Always - 45 195 Hardware_ECC_Recovered 0x001a 053 051 000 Old_age Always - 11338710 197 Current_Pending_Sector 0x0012 100 100 000 Old_age Always - 0 198 Offline_Uncorrectable 0x0010 100 100 000 Old_age Offline - 0 199 UDMA_CRC_Error_Count 0x003e 200 200 000 Old_age Always - 0 200 Multi_Zone_Error_Rate 0x0000 100 253 000 Old_age Offline - 0 202 TA_Increase_Count 0x0032 100 253 000 Old_age Always - 0 [root@3.6.0Biz-46 ~]# 上边列出的参数表中可供进行技术分析和参考，使用下边的命令可以输出完整结果： smartctl -a /dev/hdb

定期登录到服务器上运行smartctl是比较麻烦的，linux提供了系统进程smartd 编辑配置文件： vi /etc/smartd.conf 这个配置文件中大部分可能是注释掉的说明，只需要和当前硬盘相关的一行写入正确即可： /dev/hdb -H -m test@test123123.com 上边的配置表示smartd以静默状态工作，当SMART中报告PASSED的时候不理睬一旦出现Failure，立刻用邮件通知用户指定的邮箱修改配置后重启服务： /etc/init.d/smartd 即可完成对SMART的全部配置。来自:xxlinux.com

Linux 多进程监听 socket

Thu, 11 Apr 2013 15:31:17 +0800

首先来看代码

#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/wait.h>

int main() {
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd == -1 ) {
        perror("socket");
        return -1;
    }
    struct sockaddr_in serv_addr;
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(8080);
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    if (bind(sockfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) == -1) {
        perror("bind");
        return -1;
    }
    if (listen(sockfd, 20) == -1) {
        perror("listen");
        return -1;
    }
    for (int i = 0; i < 2; i++) {
        pid_t pid = fork();
        if (pid < 0) {
            perror("fork");
        } else if (pid == 0) {
            // child process
            while (1) {
                struct sockaddr_in cli_addr;
                memset(&cli_addr, 0, sizeof(cli_addr));
                socklen_t cli_addr_len = 0;
                int connfd = accept(sockfd, (struct sockaddr*)&cli_addr, &cli_addr_len);
                if (connfd == -1) {
                    perror("accept");
                    return -1;
                }
                char *cli_addr_str = inet_ntoa(cli_addr.sin_addr);
                int cli_addr_port = ntohs(cli_addr.sin_port);
                printf("pid: %d, cli addr: %s:%d\n", getpid(), cli_addr_str, cli_addr_port);
                char buff[4096] = {0};
                if (recv(connfd, buff, sizeof(buff), 0) == -1) {
                    perror("recv");
                    return -1;
                }
                char html_resp[] = "HTTP/1.1 200 OK\r\n\r\nhello";
                if (send(connfd, html_resp, strlen(html_resp), 0) == -1) {
                    perror("send");
                    return -1;
                }
                close(connfd);
            }        
        } else if (pid > 0) {
            // parent process
            printf("forked pid: %d\n", pid);
        }
    }
    while (1) {
        pid_t end_pid = wait(NULL);
        if (end_pid == -1) {
            perror("wait");
            return -1;
        }
        printf("child process %d end\n", end_pid);
    }
    close(sockfd);
    return 0;
}

编译一下

g++ -Wall -g main.cpp -o addrreuse.exe

多次模拟请求

wget http://localhost:8080/123

服务端的输出如下：

forked pid: 23278
forked pid: 23279
pid: 23278, cli addr: 0.0.0.0:0
pid: 23279, cli addr: 0.0.0.0:0
pid: 23278, cli addr: 0.0.0.0:0
pid: 23279, cli addr: 0.0.0.0:0

事实证明，是可以多个进程来 accept 一个 sockfd 的，（好吧，高手当我在说废话就行了），然后注意到有一个东西叫惊群效应，http://blog.csdn.net/chenxinl/article/details/6376895

惊群效应：指一个fd的事件被触发后，等候这个fd的所有线程/进程都被唤醒。低版本的linux内核在accept这边有所谓的“惊群效应”，是指一个链接过来，会把堵塞在accept上的所有子进程都唤醒；但是只有一个子进程都读取到链接，其他子进程唤醒后发现没有数据，继续睡觉去了；这样就产生了大量的进程切换开销。但目前的内核版本已经修复了这个问题，一个链接过来，内核只会唤醒一个子进程出来accept，这样就不用担心惊群效应了。但是对于其他类型的fd，惊群效应还是存在的，而且是必须的；比如多个进程wait在一个pipe的读事件上，有数据过来后，多个进程都会被唤醒，因为内核也不知道这些数据就给一个进程读的，还是每个进程都读一点，这个逻辑是应用层控制的；而accept也相当于一个读事件，但内核确认一个进程接受一个链接就可以了。同理，如果多个子进程把同一个listen的fd添加到各自的epoll_wait中，有链接过来会导致所有的子进程唤醒，这也会导致惊群效应；但这个是应用层面需要解决的问题。关于httpserver惊群效应和如何处理：http://bbs3.chinaunix.net/viewthread.php?action=printable&tid=1676724

但是另外看到这里，http://www.iteye.com/topic/561424

在2.6内核下，内核只会wakeup一个进程。就是说，2.6的内核下面，不会出现惊群的现象。

Linux TCP UDP 混合

Mon, 08 Apr 2013 16:07:14 +0800

基本的思路是这样的：在服务器端，有两个机器，一个对外开启 TCP 监听，然后把监听到的请求内容送到后面的另外一台，或者多台轮询机器上，内网之间使用 UDP，然后等待业务逻辑机器处理完成，这个地方可以做成异步的，然后再返回到用户。

即是这样： client <-TCP-> server_front <-UDP-> server_back

下面来看代码，首先是 server_front 的 demo

#include <stdio.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <arpa/inet.h>

#include "struct.h"

int main() {
    int tcpfd = socket(AF_INET, SOCK_STREAM, 0);
    if (tcpfd == -1) {
        perror("tcpfd socket");
        return -1;
    }
    struct sockaddr_in serv_addr;
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(38080);
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    if (bind(tcpfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) == -1) {
        perror("tcpfd bind");
        return -1;
    }
    if (listen(tcpfd, 10) == -1) {
        perror("tcpfd listen");
        return -1;
    }
    
    // udp
    int udpfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (udpfd == -1) {
        perror("udpfd socket");
        return -1;
    }
    struct sockaddr_in udp_serv_addr;
    memset(&udp_serv_addr, 0, sizeof(udp_serv_addr));
    udp_serv_addr.sin_family = AF_INET;
    udp_serv_addr.sin_port = htons(8080);
    if (inet_pton(AF_INET, "10.1.164.18", &udp_serv_addr.sin_addr) <= 0) {
        perror("udpfd inet pton");
        return -1;
    }
    
    while (1) {
        int tcp_conn_fd = accept(tcpfd, NULL, NULL);
        if (tcp_conn_fd == -1) {
            perror("tcpfd accept");
            return -1;
        }
        char buff[2048];
        memset(buff, 0, sizeof(buff));
        int recvn = recv(tcp_conn_fd, buff, sizeof(buff), 0);
        if (recvn == -1) {
            perror("tcpfd recv");
            return -1;
        }
        printf("recv: [%s]\n", buff);
        //char html_resp[] = "HTTP/1.1 200 OK\r\n\r\ntcp udp mix";
        UDP_MSG udp_msg;
        memset(&udp_msg, 0, sizeof(udp_msg));
        strcpy(udp_msg.str1, "HTTP/1.1 200 OK\r\n\r\n");
        strcpy(udp_msg.str2, "send to udp for cat");
        if (sendto(udpfd, &udp_msg, sizeof(udp_msg), 0, (struct sockaddr*)&udp_serv_addr, sizeof(udp_serv_addr)) == -1) {
            perror("udp send to");
            return -1;
        }
        if (recvfrom(udpfd, &udp_msg, sizeof(udp_msg), 0, NULL, NULL) == -1) {
            perror("udp recv from");
            return -1;
        }
        if (send(tcp_conn_fd, udp_msg.cat, strlen(udp_msg.cat), 0) == -1) {
            perror("tcp send");
            return -1;
        }
        close(tcp_conn_fd);
    }
    close(tcpfd);
    return 0;
}

然后是内部的报文格式 struct.h

#ifndef STRUCT_H
#define STRUCT_H

typedef struct _UDP_MSG {
    int add1;
    int add2;
    int sum;
    char str1[128];
    char str2[128];
    char cat[256];
} UDP_MSG;

#endif /* STRUCT_H */

然后是后端的业务逻辑服务器

#include <sys/types.h>
#include <sys/socket.h>
#include <string.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>

#include "struct.h"

#define MAX_LINE 1024
#define SERV_PORT 8080

int udp_serv();

int main() {
    return udp_serv();
}

int udp_serv() {
    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sockfd == -1) {
        perror("socket");
        return -1;
    }
    
    struct sockaddr_in serv_addr;
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    serv_addr.sin_port = htons(SERV_PORT);

    if (bind(sockfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) == -1) {
        perror("bind");
        return -1;
    }

    while (1) {
        struct sockaddr_in cli_addr;
        memset(&cli_addr, 0, sizeof(cli_addr));
        UDP_MSG msg;
        memset(&msg, 0, sizeof(msg));
        socklen_t cli_addr_len = sizeof(cli_addr);
        recvfrom(sockfd, &msg, sizeof(msg), 0, (struct sockaddr*)&cli_addr, &cli_addr_len);
        msg.sum = msg.add1 + msg.add2;
        strcpy(msg.cat, msg.str1);
        strcat(msg.cat, msg.str2);
        printf("msg.add1 is: %d\n", msg.add1);
        printf("msg.add2 is: %d\n", msg.add2);
        printf("msg.sum is: %d\n", msg.sum);
        printf("msg.str1 is: %s\n", msg.str1);
        printf("msg.str2 is: %s\n", msg.str2);
        printf("msg.cat is: %s\n", msg.cat);
        sendto(sockfd, &msg, sizeof(msg), 0, (struct sockaddr*)&cli_addr, cli_addr_len);
    }

    return 0;
}

编译一下，就可以测试了

$ wget http://localhost:38080/123 && nl 123
--16:05:03--  http://localhost:38080/123
           => `123.2'
Resolving localhost... 127.0.0.1
Connecting to localhost|127.0.0.1|:38080... connected.
HTTP request sent, awaiting response... 200 OK
Length: unspecified

    [<=> ] 19            --.--K/s             

16:05:03 (3.62 MB/s) - `123.2' saved [19]

     1	send to udp for cat

期间，server_front 的输出应该是这样的

recv: [GET /123 HTTP/1.0
User-Agent: Wget/1.10.2
Accept: */*
Host: localhost:38080
Connection: Keep-Alive

]

后台业务逻辑服务器的输出应该是这样的

msg.add1 is: 0
msg.add2 is: 0
msg.sum is: 0
msg.str1 is: HTTP/1.1 200 OK


msg.str2 is: send to udp for cat
msg.cat is: HTTP/1.1 200 OK

send to udp for cat

Linux UDP 收发实例

Sun, 07 Apr 2013 18:33:05 +0800

首先我们需要一个 struct.h

#ifndef STRUCT_H
#define STRUCT_H

typedef struct _UDP_MSG {
    int add1;
    int add2;
    int sum;
    char str1[128];
    char str2[128];
    char cat[256];
} UDP_MSG;

#endif /* STRUCT_H */

然后是服务端的

#include <sys/types.h>
#include <sys/socket.h>
#include <string.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>

#include "struct.h"

#define MAX_LINE 1024
#define SERV_PORT 8080

int udp_serv();

int main() {
    return udp_serv();
}

int udp_serv() {
    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sockfd == -1) {
        perror("socket");
        return -1;
    }
    
    struct sockaddr_in serv_addr;
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    serv_addr.sin_port = htons(SERV_PORT);

    if (bind(sockfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) == -1) {
        perror("bind");
        return -1;
    }

    while (1) {
        struct sockaddr_in cli_addr;
        memset(&cli_addr, 0, sizeof(cli_addr));
        UDP_MSG msg;
        memset(&msg, 0, sizeof(msg));
        socklen_t cli_addr_len = sizeof(cli_addr);
        recvfrom(sockfd, &msg, sizeof(msg), 0, (struct sockaddr*)&cli_addr, &cli_addr_len);
        msg.sum = msg.add1 + msg.add2;
        strcpy(msg.cat, msg.str1);
        strcat(msg.cat, msg.str2);
        printf("msg.add1 is: %d\n", msg.add1);
        printf("msg.add2 is: %d\n", msg.add2);
        printf("msg.sum is: %d\n", msg.sum);
        printf("msg.str1 is: %s\n", msg.str1);
        printf("msg.str2 is: %s\n", msg.str2);
        printf("msg.cat is: %s\n", msg.cat);
        sendto(sockfd, &msg, sizeof(msg), 0, (struct sockaddr*)&cli_addr, cli_addr_len);
    }

    return 0;
}

然后是客户端的

#include <sys/types.h>
#include <sys/socket.h>
#include <string.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>
#include <arpa/inet.h>
#include <unistd.h>

#include "struct.h"

#define MAX_LINE 1024
#define SERV_PORT 8080

int udp_cli(const char* serv_ip);

int main(int argc, char* argv[]) {
    if (argc < 2) {
        printf("Usage: %s serv_ip\n", argv[0]);
        return 1;
    }
    return udp_cli(argv[1]);
}

int udp_cli(const char* serv_ip) {
    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sockfd == -1) {
        perror("socket");
        return -1;
    }
    struct sockaddr_in serv_addr;
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(SERV_PORT);
    if (inet_pton(AF_INET, serv_ip, &serv_addr.sin_addr) <= 0) {
        perror("inet_pton");
        return -1;
    }
    while (1) {
        UDP_MSG msg;
        memset(&msg, 0, sizeof(msg));
        msg.add1 = 1;
        msg.add2 = 2;
        sprintf(msg.str1, "hello ");
        sprintf(msg.str2, "world");
        if (sendto(sockfd, &msg, sizeof(msg), 0,
            (struct sockaddr*)&serv_addr, sizeof(serv_addr)) == -1) {
            perror("write");
            return -1;
        }
        socklen_t serv_addr_len = sizeof(serv_addr);
        if (recvfrom(sockfd, &msg, sizeof(msg), 0,
            (struct sockaddr*)&serv_addr, &serv_addr_len) == -1) {
            perror("read");
            return -1;
        }
        printf("msg.add1 is: %d\n", msg.add1);
        printf("msg.add2 is: %d\n", msg.add2);
        printf("msg.sum is: %d\n", msg.sum);
        printf("msg.str1 is: %s\n", msg.str1);
        printf("msg.str2 is: %s\n", msg.str2);
        printf("msg.cat is: %s\n", msg.cat);
        break;
    }
    return 0;
}

客户端另外一种，像这样的写法也行。。

#include <sys/types.h>
#include <sys/socket.h>
#include <string.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>
#include <arpa/inet.h>
#include <unistd.h>

#include "struct.h"

#define MAX_LINE 1024
#define SERV_PORT 8080

int udp_cli(const char* serv_ip);

int main(int argc, char* argv[]) {
    if (argc < 2) {
        printf("Usage: %s serv_ip\n", argv[0]);
        return 1;
    }
    return udp_cli(argv[1]);
}

int udp_cli(const char* serv_ip) {
    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sockfd == -1) {
        perror("socket");
        return -1;
    }
    struct sockaddr_in serv_addr;
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(SERV_PORT);
    if (inet_pton(AF_INET, serv_ip, &serv_addr.sin_addr) <= 0) {
        perror("inet_pton");
        return -1;
    }
    if (connect(sockfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) == -1) {
        perror("connect");
        return -1;
    }
    while (1) {
        UDP_MSG msg;
        memset(&msg, 0, sizeof(msg));
        msg.add1 = 1;
        msg.add2 = 2;
        sprintf(msg.str1, "hello ");
        sprintf(msg.str2, "world");
        if (write(sockfd, &msg, sizeof(msg)) == -1) {
            perror("write");
            return -1;
        }
        if (read(sockfd, &msg, sizeof(msg)) == -1) {
            perror("read");
            return -1;
        }
        printf("msg.add1 is: %d\n", msg.add1);
        printf("msg.add2 is: %d\n", msg.add2);
        printf("msg.sum is: %d\n", msg.sum);
        printf("msg.str1 is: %s\n", msg.str1);
        printf("msg.str2 is: %s\n", msg.str2);
        printf("msg.cat is: %s\n", msg.cat);
        break;
    }
    return 0;
}

然后编译

g++ -Wall -g serv.cpp -o serv.exe
g++ -Wall -g cli.cpp -o cli.exe

就可以运行了

历史评论

ZRJ (2013-04-07 18:33:34):

补充来源：http://www.chinaitpower.com/A200508/2005-08-02/182672.html

共享内存的读写

Tue, 26 Mar 2013 17:32:22 +0800

首先我们需要一个 shm_com.h

#ifndef _SHM_COM_H_
#define _SHM_COM_H_

#define TEXT_SZ 2048

struct shared_use_st {
    int written_by_you;
    char some_text[TEXT_SZ];
};

#endif /* _SHM_COM_H  */

然后是 shm1.cpp

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>

#include "shm_com.h"

int main() {
    int running = 1;
    void* shared_memory = (void *)0;
    struct shared_use_st* shared_stuff;
    int shmid;

    srand((unsigned int)getpid());
    shmid = shmget((key_t)1234, sizeof(struct shared_use_st), 0666|IPC_CREAT);
    if (shmid == -1) {
        perror("shmget");
        exit(EXIT_FAILURE);
    }

    shared_memory = shmat(shmid, (void *)0, 0);
    if (shared_memory == (void *)-1) {
        perror("shmat");
        exit(EXIT_FAILURE);
    }

    printf("Memory attached at %X\n", (int)shared_memory);

    shared_stuff = (struct shared_use_st *)shared_memory;
    shared_stuff->written_by_you = 0;
    while (running) {
        if (shared_stuff->written_by_you) {
            printf("You wrote: %s", shared_stuff->some_text);
            sleep(rand() % 4);
            shared_stuff->written_by_you = 0;
            if (strncmp(shared_stuff->some_text, "end", 3) == 0) {
                running = 0;
            }
        }
    }

    if (shmdt(shared_memory) == -1) {
        perror("shmdt");
        exit(EXIT_FAILURE);
    }

    if (shmctl(shmid, IPC_RMID, 0) == -1) {
        perror("shmctl");
        exit(EXIT_FAILURE);
    }
   
    return 0;
}

然后是 shm2.cpp

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>

#include "shm_com.h"

int main() {
    int running = 1;
    void* shared_memory = (void *)0;
    struct shared_use_st* shared_stuff;
    char buffer[TEXT_SZ];
    
    int shmid = shmget((key_t)1234, sizeof(struct shared_use_st), 0666);
    if (shmid == -1) {
        perror("shmget");
        exit(EXIT_FAILURE);
    }

    shared_memory = shmat(shmid, (void *)0, 0);
    if (shared_memory == (void *)-1) {
        perror("shmat");
        exit(EXIT_FAILURE);
    }

    printf("Memory attached at %X\n", (int)shared_memory);

    shared_stuff = (struct shared_use_st *)shared_memory;

    while (running) {
        while (shared_stuff->written_by_you == 1) {
            sleep(1);
            printf("waiting for client...\n");
        }
        printf("Enter some text: ");
        fgets(buffer, TEXT_SZ, stdin);
        strncpy(shared_stuff->some_text, buffer, TEXT_SZ);
        shared_stuff->written_by_you = 1;

        if (strncmp(buffer, "end", 3) == 0) {
            running = 0;
        }
    }

    if (shmdt(shared_memory) == -1) {
        perror("shmdt");
        exit(EXIT_FAILURE);
    }
    
    return 0;
}

编译一下

g++ -g -Wall shm1.cpp -o shm1.exe
g++ -g -Wall shm2.cpp -o shm2.exe

就可以运行了

-——————————————————————-

2013-03-28 20:04:11 update：注意 shmdt 和 shmctl 两种方式结束共享内存是不同的，shmdt 只是当前进程脱离共享内存，不对内存造成其他影响，而 shmctl 方式是删除这片内存，那样的话，其他的进程就再也无法 attach 这片内存了（已经 attach 上的可以继续）用，但是系统会把这片内存标记为 dest

[转]一份高质量的 Epoll 服务端代码

Mon, 25 Mar 2013 14:10:37 +0800

来自https://banu.com/blog/2/how-to-use-epoll-a-complete-example-in-c/epoll-example.c，由http://www.oschina.net/translate/how-to-use-epoll-a-complete-example-in-c?from=20130303提及

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/epoll.h>
#include <errno.h>

#define MAXEVENTS 64

static int
make_socket_non_blocking (int sfd)
{
  int flags, s;

  flags = fcntl (sfd, F_GETFL, 0);
  if (flags == -1)
    {
      perror ("fcntl");
      return -1;
    }

  flags |= O_NONBLOCK;
  s = fcntl (sfd, F_SETFL, flags);
  if (s == -1)
    {
      perror ("fcntl");
      return -1;
    }

  return 0;
}

static int
create_and_bind (char *port)
{
  struct addrinfo hints;
  struct addrinfo *result, *rp;
  int s, sfd;

  memset (&hints, 0, sizeof (struct addrinfo));
  hints.ai_family = AF_UNSPEC;     /* Return IPv4 and IPv6 choices */
  hints.ai_socktype = SOCK_STREAM; /* We want a TCP socket */
  hints.ai_flags = AI_PASSIVE;     /* All interfaces */

  s = getaddrinfo (NULL, port, &hints, &result);
  if (s != 0)
    {
      fprintf (stderr, "getaddrinfo: %s\n", gai_strerror (s));
      return -1;
    }

  for (rp = result; rp != NULL; rp = rp->ai_next)
    {
      sfd = socket (rp->ai_family, rp->ai_socktype, rp->ai_protocol);
      if (sfd == -1)
        continue;

      s = bind (sfd, rp->ai_addr, rp->ai_addrlen);
      if (s == 0)
        {
          /* We managed to bind successfully! */
          break;
        }

      close (sfd);
    }

  if (rp == NULL)
    {
      fprintf (stderr, "Could not bind\n");
      return -1;
    }

  freeaddrinfo (result);

  return sfd;
}

int
main (int argc, char *argv[])
{
  int sfd, s;
  int efd;
  struct epoll_event event;
  struct epoll_event *events;

  if (argc != 2)
    {
      fprintf (stderr, "Usage: %s [port]\n", argv[0]);
      exit (EXIT_FAILURE);
    }

  sfd = create_and_bind (argv[1]);
  if (sfd == -1)
    abort ();

  s = make_socket_non_blocking (sfd);
  if (s == -1)
    abort ();

  s = listen (sfd, SOMAXCONN);
  if (s == -1)
    {
      perror ("listen");
      abort ();
    }

  efd = epoll_create1 (0);
  if (efd == -1)
    {
      perror ("epoll_create");
      abort ();
    }

  event.data.fd = sfd;
  event.events = EPOLLIN | EPOLLET;
  s = epoll_ctl (efd, EPOLL_CTL_ADD, sfd, &event);
  if (s == -1)
    {
      perror ("epoll_ctl");
      abort ();
    }

  /* Buffer where events are returned */
  events = calloc (MAXEVENTS, sizeof event);

  /* The event loop */
  while (1)
    {
      int n, i;

      n = epoll_wait (efd, events, MAXEVENTS, -1);
      for (i = 0; i < n; i++)
	{
	  if ((events[i].events & EPOLLERR) ||
              (events[i].events & EPOLLHUP) ||
              (!(events[i].events & EPOLLIN)))
	    {
              /* An error has occured on this fd, or the socket is not
                 ready for reading (why were we notified then?) */
	      fprintf (stderr, "epoll error\n");
	      close (events[i].data.fd);
	      continue;
	    }

	  else if (sfd == events[i].data.fd)
	    {
              /* We have a notification on the listening socket, which
                 means one or more incoming connections. */
              while (1)
                {
                  struct sockaddr in_addr;
                  socklen_t in_len;
                  int infd;
                  char hbuf[NI_MAXHOST], sbuf[NI_MAXSERV];

                  in_len = sizeof in_addr;
                  infd = accept (sfd, &in_addr, &in_len);
                  if (infd == -1)
                    {
                      if ((errno == EAGAIN) ||
                          (errno == EWOULDBLOCK))
                        {
                          /* We have processed all incoming
                             connections. */
                          break;
                        }
                      else
                        {
                          perror ("accept");
                          break;
                        }
                    }

                  s = getnameinfo (&in_addr, in_len,
                                   hbuf, sizeof hbuf,
                                   sbuf, sizeof sbuf,
                                   NI_NUMERICHOST | NI_NUMERICSERV);
                  if (s == 0)
                    {
                      printf("Accepted connection on descriptor %d "
                             "(host=%s, port=%s)\n", infd, hbuf, sbuf);
                    }

                  /* Make the incoming socket non-blocking and add it to the
                     list of fds to monitor. */
                  s = make_socket_non_blocking (infd);
                  if (s == -1)
                    abort ();

                  event.data.fd = infd;
                  event.events = EPOLLIN | EPOLLET;
                  s = epoll_ctl (efd, EPOLL_CTL_ADD, infd, &event);
                  if (s == -1)
                    {
                      perror ("epoll_ctl");
                      abort ();
                    }
                }
              continue;
            }
          else
            {
              /* We have data on the fd waiting to be read. Read and
                 display it. We must read whatever data is available
                 completely, as we are running in edge-triggered mode
                 and won't get a notification again for the same
                 data. */
              int done = 0;

              while (1)
                {
                  ssize_t count;
                  char buf[512];

                  count = read (events[i].data.fd, buf, sizeof buf);
                  if (count == -1)
                    {
                      /* If errno == EAGAIN, that means we have read all
                         data. So go back to the main loop. */
                      if (errno != EAGAIN)
                        {
                          perror ("read");
                          done = 1;
                        }
                      break;
                    }
                  else if (count == 0)
                    {
                      /* End of file. The remote has closed the
                         connection. */
                      done = 1;
                      break;
                    }

                  /* Write the buffer to standard output */
                  s = write (1, buf, count);
                  if (s == -1)
                    {
                      perror ("write");
                      abort ();
                    }
                }

              if (done)
                {
                  printf ("Closed connection on descriptor %d\n",
                          events[i].data.fd);

                  /* Closing the descriptor will make epoll remove it
                     from the set of descriptors which are monitored. */
                  close (events[i].data.fd);
                }
            }
        }
    }

  free (events);

  close (sfd);

  return EXIT_SUCCESS;
}

不同服务器端模型在并发请求下的表现差异

Mon, 25 Mar 2013 11:22:04 +0800

一般来说，服务器的模型有下面几种：

单进程单线程
多进程（一个请求对应一个进程，Apache 之类貌似就是这个）
多线程（一个请求对应一个线程，这个挺少见到的）
select / poll
epoll

它们的差别可以看这个，http://www.cnblogs.com/sharra/archive/2010/12/30/1921287.html

因为需要了解底层设备访问的原理，所以惯用高层应用语言的我，需要了解一下Linux的设备访问机制，尤其是处理一组非阻塞IO的原理方法，标准的术语好像是叫多路复用。以下文章部分句子有引用之处，恕没有一一指出出处。对于接触过Linux内核或设备驱动开发的读者，一定清楚poll和select系统调用，以及从2.5版本引入的epoll机制（epoll机制包含三个系统调用）。网上关于它们的文章，有说用法的，甚为详细，更有分析源代码的，又比较深入，且枝节颇多。经过几篇文章的阅读，我把觉得比较核心的东西写下来吧。我的用意是尽可能以简单的概念，比对他们三者的异同。几经查找我才确定下来，poll和select应该被归类为这样的系统调用，它们可以阻塞地同时探测一组支持非阻塞的IO设备，是否有事件发生（如可读，可写，有高优先级的错误输出，出现错误等等），直至某一个设备触发了事件或者超过了指定的等待时间——也就是它们的职责不是做IO，而是帮助调用者寻找当前就绪的设备。同类型的产品是Windows的IOCP，它也是处理多路复用，只是把IO和探测封装在了一起了。准备的知识有两点：1、fd；2、op->poll。在Linux里面，设备都被抽象为文件，一系列的设备文件就有自己独立的虚拟文件系统，所以，设备在系统调用参数中的表示就是file description。fd其实就是一个整数（特别地，标准输入，输出，错误输出分别对应的fd是0，1，2）。与内核打交道的时候，传递整数的fd可以在自己的文件系统中作进一步的检查是否合法，如果只是返回指针就不能这样操作了，毕竟指针是无差别无意义的。通过fd访问file，通过file可以访问其fileOperator，这里面我们要关心的一个fileOp就是poll。因为系统调用poll和select，就是依靠这个文件操作poll实现的。poll文件操作有两个参数，一个是文件本身，一个可以看做是当设备尚未就绪时调用的回调函数，这个函数是把设备自己特有的等待队列传给内核，让内核把当前的进程挂载到其中（因为当设备就绪时，设备就应该去唤醒在自己特有等待队列中的所有节点，这样当前进程就获取了完成的信号了）。poll文件操作返回的必须是一组标准的掩码，其中的各个位指示当前的不同的就绪状态（全0为没有任何事件触发）。再谈谈早期多路复用的版本poll和select。本质而言，poll和select的共同点就是，对全部指定设备做一次poll，当然这往往都是还没有就绪的，那就会通过回调函数把当前进程注册到设备的等待队列，如果所有设备返回的掩码都没有显示任何的事件触发，就去掉回调函数的函数指针，进入有限时的睡眠状态，再恢复和不断做poll，再作有限时的睡眠，直到其中一个设备有事件触发为止。只要有事件触发，系统调用返回，回到用户态，用户就可以对相关的fd作进一步的读或者写操作了。当然，这个时候还不是所有的设备都就绪的喔，那就得不断地poll或者select了，而做一次这样的系统调用都得轮询所有的设备，次数是设备数*（睡眠次数-1），也就是时间复杂度是O（n），还得做几次O（n）呢。可见，对于现在普遍的服务器程序，需要同时并发监听数千个连接，并且连接需要重复使用的情况，poll和select就存在这样的性能瓶颈。另外，数千个设备fd在每次调用时，都需要将其从用户空间复制到内核空间，这里的开销不可忽略。 poll和select放在一起，是因为其机制一致，而参数和数据结构就略有不同。select一次性传入三组作用于不同信道的设备fd，分别是输入，输出和错误异常。各组的fd期待各组所特有的，由代码指定的一组事件，如输入信道期待输入就绪，输入挂起和错误等事件。然后，select就挑选调用者关心的fd做poll文件操作，检测返回的掩码，看看是否有fd所属信道感兴趣的事件，比如看看这个属于输出信道的fd有没有输出就绪等一系列的事件发生，一样地，如果有一个fd发生感兴趣事件就返回调用了。select，为了同时处理三组使用不同的事件判断规则的fd，采用了位图的方式表示，一组一个位图，位长度是当中最大的fd值，上限是1024，三组就是3072，而且这还只是传入的位图，还有一样大小的传出的位图。当fd数越来越多时，所需的存储开销比较大。既然，一组fd处理起来比较粗放，那就各个fd自己准备好了。poll()系统调用是System V的多元I/O解决方案。它有三个参数，第一个是pollfd结构的数组指针，也就是指向一组fd及其相关信息的指针，因为这个结构包含的除了fd，还有期待的事件掩码和返回的事件掩码，实质上就是将select的中的fd，传入和传出参数归到一个结构之下，也不再把fd分为三组，也不再硬性规定fd感兴趣的事件，这由调用者自己设定。这样，不使用位图来组织数据，也就不需要位图的全部遍历了。按照一般队列地遍历，每个fd做poll文件操作，检查返回的掩码是否有期待的事件，以及做是否有挂起和错误的必要性检查，如果有事件触发，就可以返回调用了。回到poll和select的共同点，面对高并发多连接的应用情境，它们显现出原来没有考虑到的不足，虽然poll比起select又有所改进了。除了上述的关于每次调用都需要做一次从用户空间到内核空间的拷贝，还有这样的问题，就是当处于这样的应用情境时，poll和select会不得不多次操作，并且每次操作都很有可能需要多次进入睡眠状态，也就是多次全部轮询fd，我们应该怎么处理一些会出现重复而无意义的操作。这些重复而无意义的操作有：1、从用户到内核空间拷贝，既然长期监视这几个fd，甚至连期待的事件也不会改变，那拷贝无疑就是重复而无意义的，我们可以让内核长期保存所有需要监视的fd甚至期待事件，或者可以再需要时对部分期待事件进行修改；2、将当前线程轮流加入到每个fd对应设备的等待队列，这样做无非是哪一个设备就绪时能够通知进程退出调用，聪明的开发者想到，那就找个“代理”的回调函数，代替当前进程加入fd的等待队列好了（这也是我后来才总结出来，Linux的等待队列，实质上是回调函数队列吧，也可以使用宏来将当前进程“加入”等待队列，其实就是将唤醒当前进程的回调函数加入队列）。这样，像poll系统调用一样，做poll文件操作发现尚未就绪时，它就调用传入的一个回调函数，这是epoll指定的回调函数，它不再像以前的poll系统调用指定的回调函数那样，而是就将那个“代理”的回调函数加入设备的等待队列就好了，这个代理的回调函数就自己乖乖地等待设备就绪时将它唤醒，然后它就把这个设备fd放到一个指定的地方，同时唤醒可能在等待的进程，到这个指定的地方取fd就好了。我们把1和2结合起来就可以这样做了，只拷贝一次fd，一旦确定了fd就可以做poll文件操作，如果有事件当然好啦，马上就把fd放到指定的地方，而通常都是没有的，那就给这个fd的等待队列加一个回调函数，有事件就自动把fd放到指定的地方，当前进程不需要再一个个poll和睡眠等待了。 epoll机制就是这样改进的了。诚然，fd少的时候，当前进程一个个地等问题不大，可是现在和尚多了，方丈就不好管了。以前设备事件触发时，只负责唤醒当前进程就好了，而当前进程也只能傻傻地在poll里面等待或者循环，再来一次poll，也不知道这个由设备提供的poll性能如何，能不能检查出当前进程已经在等待了就立即返回，当然，我也不明白为什么做了一遍的poll之后，去掉回调函数指针了，还得再做，不是说好了会去唤醒进程的吗？现在就让事件触发回调函数多做一步。本来设备还没就绪就调用一个回调函数了，现在再在这个回调函数里面做一个注册另一个回调函数的操作，目的就是使得设备事件触发多走一步，不仅仅是唤醒当前进程，还要把自己的fd放到指定的地方。就像收本子的班长，以前得一个个学生地去问有没有本子，如果没有，它还得等待一段时间而后又继续问，现在好了，只走一次，如果没有本子，班长就告诉大家去那里交本子，当班长想起要取本子，就去那里看看或者等待一定时间后离开，有本子到了就叫醒他，然后取走。这个道理很简单，就是老师和班干们常说的，大家多做一点工作，我的工作就轻松很多了，尤其是需要管理的东西越来越多时。这种机制或者说模式，我想在Java的FutureTask里面应该也会用到的，一堆在线程池里面跑着的线程（当然这是任务，不是线程，接口是Callable，不是Runnable.run，是Callable.call，它是可以返回结果的），谁先做好就应该先处理呀，可是难道得一个个问吗？干脆就谁好了，谁就按照既定的操作暴露自己，这样FutureTask的get方法就可以马上知道当前最先完成的线程了，就可以取此线程返回结果了。 epoll由三个系统调用组成，分别是epoll_create，epoll_ctl和epoll_wait。epoll_create用于创建和初始化一些内部使用的数据结构；epoll_ctl用于添加，删除或者修改指定的fd及其期待的事件，epoll_wait就是用于等待任何先前指定的fd事件。关于epoll内部的数据结构，我就不能详细了解了。

下面就是分别实现一个 demo，然后用 ab 去压力测试，每回都是 10W 个请求，根据不同的并发量测试

单进程单线程

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>

#define BUFFER_SIZE 4096

int tcpSrv(int listen_port);

int main(int argc, char** argv) {
    tcpSrv(8080);
    return 0;
}

int tcpSrv(int listen_port) {
    int listenfd, connfd;
    struct sockaddr_in servaddr;
    char buff[BUFFER_SIZE+1];
    int n;

    if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
        printf("create socket error: %s(errno: %d)\n", strerror(errno), errno);
        return -1;
    }

    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    servaddr.sin_port = htons(listen_port);

    if (bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) == -1) {
        printf("bind socket error: %s(errno: %d)\n", strerror(errno), errno);
        close(listenfd);
        return -1;
    }

    if (listen(listenfd, 2048) == -1) {
        printf("listen socket error: %s(errno: %d)\n", strerror(errno), errno);
        close(listenfd);
        return -1;
    }

    printf("-----waiting for client's request-----\n");
    while (1) {
        if ((connfd = accept(listenfd, (struct sockaddr *)NULL, NULL)) == -1) {
            printf("accept socket error: %s(errno: %d)\n", strerror(errno), errno);
            close(listenfd);
            return -1;
        }
        memset(&buff, 0, sizeof(buff));
        recv(connfd, buff, BUFFER_SIZE, 0);
        //printf("recv msg:\n%s\n", buff);
        char resp[] = "HTTP/1.0 200 OK\r\n\r\n<html>hello</html>";
        send(connfd, resp, strlen(resp), 0);
        close(connfd);
    }
    
    close(listenfd);
    return 0;
}

一开始觉得这种简单粗暴的方式肯定不行，结果发现还别说，这东西的处理能力还是可以的，看测试结果

单并发

linux:~/ab/httpd-2.4.3/support$ ./ab -n 100000 -c 1 http://localhost:8080/
This is ApacheBench, Version 2.3 <$Revision: 1373084 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking localhost (be patient)
Completed 10000 requests
Completed 20000 requests
Completed 30000 requests
Completed 40000 requests
Completed 50000 requests
Completed 60000 requests
Completed 70000 requests
Completed 80000 requests
Completed 90000 requests
Completed 100000 requests
Finished 100000 requests


Server Software:        
Server Hostname:        localhost
Server Port:            8080

Document Path:          /
Document Length:        18 bytes

Concurrency Level:      1
Time taken for tests:   7.210 seconds
Complete requests:      100000
Failed requests:        0
Write errors:           0
Total transferred:      3700000 bytes
HTML transferred:       1800000 bytes
Requests per second:    13869.50 [#/sec] (mean)
Time per request:       0.072 [ms] (mean)
Time per request:       0.072 [ms] (mean, across all concurrent requests)
Transfer rate:          501.14 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    0   0.0      0       4
Processing:     0    0   0.0      0       4
Waiting:        0    0   0.0      0       4
Total:          0    0   0.0      0       4

Percentage of the requests served within a certain time (ms)
  50%      0
  66%      0
  75%      0
  80%      0
  90%      0
  95%      0
  98%      0
  99%      0
 100%      4 (longest request)
linux:~/ab/httpd-2.4.3/support$

10 个并发

linux:~/ab/httpd-2.4.3/support$ ./ab -n 100000 -c 10 http://localhost:8080/
This is ApacheBench, Version 2.3 <$Revision: 1373084 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking localhost (be patient)
Completed 10000 requests
Completed 20000 requests
Completed 30000 requests
Completed 40000 requests
Completed 50000 requests
Completed 60000 requests
Completed 70000 requests
Completed 80000 requests
Completed 90000 requests
Completed 100000 requests
Finished 100000 requests


Server Software:        
Server Hostname:        localhost
Server Port:            8080

Document Path:          /
Document Length:        18 bytes

Concurrency Level:      10
Time taken for tests:   5.498 seconds
Complete requests:      100000
Failed requests:        0
Write errors:           0
Total transferred:      3700000 bytes
HTML transferred:       1800000 bytes
Requests per second:    18186.97 [#/sec] (mean)
Time per request:       0.550 [ms] (mean)
Time per request:       0.055 [ms] (mean, across all concurrent requests)
Transfer rate:          657.15 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    0   0.1      0       6
Processing:     0    0   0.1      0       6
Waiting:        0    0   0.1      0       6
Total:          0    1   0.1      1       6

Percentage of the requests served within a certain time (ms)
  50%      1
  66%      1
  75%      1
  80%      1
  90%      1
  95%      1
  98%      1
  99%      1
 100%      6 (longest request)
linux:~/ab/httpd-2.4.3/support$

100 个并发

linux:~/ab/httpd-2.4.3/support$ ./ab -n 100000 -c 100 http://localhost:8080/
This is ApacheBench, Version 2.3 <$Revision: 1373084 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking localhost (be patient)
Completed 10000 requests
Completed 20000 requests
Completed 30000 requests
Completed 40000 requests
Completed 50000 requests
Completed 60000 requests
Completed 70000 requests
Completed 80000 requests
Completed 90000 requests
Completed 100000 requests
Finished 100000 requests


Server Software:        
Server Hostname:        localhost
Server Port:            8080

Document Path:          /
Document Length:        18 bytes

Concurrency Level:      100
Time taken for tests:   5.816 seconds
Complete requests:      100000
Failed requests:        0
Write errors:           0
Total transferred:      3700000 bytes
HTML transferred:       1800000 bytes
Requests per second:    17194.97 [#/sec] (mean)
Time per request:       5.816 [ms] (mean)
Time per request:       0.058 [ms] (mean, across all concurrent requests)
Transfer rate:          621.30 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    1   0.6      1      11
Processing:     1    5   0.8      5      15
Waiting:        0    2   0.6      2      12
Total:          2    6   0.6      6      15

Percentage of the requests served within a certain time (ms)
  50%      6
  66%      6
  75%      6
  80%      6
  90%      6
  95%      6
  98%      7
  99%      7
 100%     15 (longest request)
linux:~/ab/httpd-2.4.3/support$

150 个并发的时候就不行了

linux:~/ab/httpd-2.4.3/support$ ./ab -n 100000 -c 150 http://localhost:8080/
This is ApacheBench, Version 2.3 <$Revision: 1373084 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking localhost (be patient)
Completed 10000 requests
Completed 20000 requests
Completed 30000 requests
Completed 40000 requests
Completed 50000 requests
Completed 60000 requests
Completed 70000 requests
Completed 80000 requests
Completed 90000 requests
apr_pollset_poll: The timeout specified has expired (70007)
Total of 99956 requests completed
linux:~/ab/httpd-2.4.3/support$

接下来是多进程模型

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>

#define BUFFER_SIZE 4096

int tcpSrv(int listen_port);

int main(int argc, char** argv) {
    tcpSrv(8080);
    return 0;
}

int tcpSrv(int listen_port) {
    int listenfd, connfd;
    struct sockaddr_in servaddr;
    char buff[BUFFER_SIZE+1];
    int n;

    if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
        printf("create socket error: %s(errno: %d)\n", strerror(errno), errno);
        return -1;
    }

    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    servaddr.sin_port = htons(listen_port);

    if (bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) == -1) {
        printf("bind socket error: %s(errno: %d)\n", strerror(errno), errno);
        close(listenfd);
        return -1;
    }

    if (listen(listenfd, 2048) == -1) {
        printf("listen socket error: %s(errno: %d)\n", strerror(errno), errno);
        close(listenfd);
        return -1;
    }

    printf("-----waiting for client's request-----\n");
    while (1) {
        if ((connfd = accept(listenfd, (struct sockaddr *)NULL, NULL)) == -1) {
            printf("accept socket error: %s(errno: %d)\n", strerror(errno), errno);
            close(listenfd);
            return -1;
        }
        signal(SIGCHLD, SIG_IGN);
        pid_t pid = fork();
        if (pid < 0) {
            printf("fork error: %s(errno: %d)\n", strerror(errno), errno);
            close(listenfd);
            return -1;
        } else if (pid == 0) {
            //printf("in child process\n");
            memset(&buff, 0, sizeof(buff));
            recv(connfd, buff, BUFFER_SIZE, 0);
            //printf("recv msg:\n%s\n", buff);
            char resp[] = "HTTP/1.0 200 OK\r\n\r\n<html>hello</html>";
            send(connfd, resp, strlen(resp), 0);
            close(connfd);
            exit(0);
        } else if (pid > 0) {
            //printf("in parent process\n");
            close(connfd);
            continue;
        }
    }
    
    close(listenfd);
    return 0;
}

单并发

linux:~/ab/httpd-2.4.3/support$ ./ab -n 100000 -c 1 http://localhost:8080/
This is ApacheBench, Version 2.3 <$Revision: 1373084 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking localhost (be patient)
Completed 10000 requests
Completed 20000 requests
Completed 30000 requests
Completed 40000 requests
Completed 50000 requests
Completed 60000 requests
Completed 70000 requests
Completed 80000 requests
Completed 90000 requests
Completed 100000 requests
Finished 100000 requests


Server Software:        
Server Hostname:        localhost
Server Port:            8080

Document Path:          /
Document Length:        18 bytes

Concurrency Level:      1
Time taken for tests:   41.408 seconds
Complete requests:      100000
Failed requests:        0
Write errors:           0
Total transferred:      3700000 bytes
HTML transferred:       1800000 bytes
Requests per second:    2415.02 [#/sec] (mean)
Time per request:       0.414 [ms] (mean)
Time per request:       0.414 [ms] (mean, across all concurrent requests)
Transfer rate:          87.26 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    0   0.0      0       0
Processing:     0    0   0.1      0       9
Waiting:        0    0   0.1      0       9
Total:          0    0   0.1      0       9

Percentage of the requests served within a certain time (ms)
  50%      0
  66%      0
  75%      0
  80%      0
  90%      0
  95%      0
  98%      0
  99%      0
 100%      9 (longest request)
linux:~/ab/httpd-2.4.3/support$

10 个并发

linux:~/ab/httpd-2.4.3/support$ ./ab -n 100000 -c 10 http://localhost:8080/
This is ApacheBench, Version 2.3 <$Revision: 1373084 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking localhost (be patient)
Completed 10000 requests
Completed 20000 requests
Completed 30000 requests
Completed 40000 requests
Completed 50000 requests
Completed 60000 requests
Completed 70000 requests
Completed 80000 requests
Completed 90000 requests
Completed 100000 requests
Finished 100000 requests


Server Software:        
Server Hostname:        localhost
Server Port:            8080

Document Path:          /
Document Length:        18 bytes

Concurrency Level:      10
Time taken for tests:   39.517 seconds
Complete requests:      100000
Failed requests:        0
Write errors:           0
Total transferred:      3700000 bytes
HTML transferred:       1800000 bytes
Requests per second:    2530.53 [#/sec] (mean)
Time per request:       3.952 [ms] (mean)
Time per request:       0.395 [ms] (mean, across all concurrent requests)
Transfer rate:          91.44 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    0   0.0      0       3
Processing:     0    4   0.4      4      64
Waiting:        0    4   0.4      4      64
Total:          1    4   0.4      4      64

Percentage of the requests served within a certain time (ms)
  50%      4
  66%      4
  75%      4
  80%      4
  90%      4
  95%      4
  98%      4
  99%      4
 100%     64 (longest request)
linux:~/ab/httpd-2.4.3/support$

100 个并发

linux:~/ab/httpd-2.4.3/support$ ./ab -n 100000 -c 100 http://localhost:8080/
This is ApacheBench, Version 2.3 <$Revision: 1373084 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking localhost (be patient)
Completed 10000 requests
Completed 20000 requests
Completed 30000 requests
Completed 40000 requests
Completed 50000 requests
Completed 60000 requests
Completed 70000 requests
Completed 80000 requests
Completed 90000 requests
Completed 100000 requests
Finished 100000 requests


Server Software:        
Server Hostname:        localhost
Server Port:            8080

Document Path:          /
Document Length:        18 bytes

Concurrency Level:      100
Time taken for tests:   39.980 seconds
Complete requests:      100000
Failed requests:        0
Write errors:           0
Total transferred:      3700000 bytes
HTML transferred:       1800000 bytes
Requests per second:    2501.28 [#/sec] (mean)
Time per request:       39.980 [ms] (mean)
Time per request:       0.400 [ms] (mean, across all concurrent requests)
Transfer rate:          90.38 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    0   0.3      0      17
Processing:     0   40   1.7     40     120
Waiting:        0   40   1.7     40     120
Total:          3   40   1.6     40     120

Percentage of the requests served within a certain time (ms)
  50%     40
  66%     40
  75%     41
  80%     41
  90%     41
  95%     42
  98%     43
  99%     44
 100%    120 (longest request)
linux:~/ab/httpd-2.4.3/support$

500 个并发

linux:~/ab/httpd-2.4.3/support$ ./ab -n 100000 -c 500 http://localhost:8080/
This is ApacheBench, Version 2.3 <$Revision: 1373084 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking localhost (be patient)
Completed 10000 requests
Completed 20000 requests
Completed 30000 requests
Completed 40000 requests
Completed 50000 requests
Completed 60000 requests
Completed 70000 requests
Completed 80000 requests
Completed 90000 requests
Completed 100000 requests
Finished 100000 requests


Server Software:        
Server Hostname:        localhost
Server Port:            8080

Document Path:          /
Document Length:        18 bytes

Concurrency Level:      500
Time taken for tests:   63.222 seconds
Complete requests:      100000
Failed requests:        0
Write errors:           0
Total transferred:      3700000 bytes
HTML transferred:       1800000 bytes
Requests per second:    1581.72 [#/sec] (mean)
Time per request:       316.112 [ms] (mean)
Time per request:       0.632 [ms] (mean, across all concurrent requests)
Transfer rate:          57.15 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0   38 520.0      0   21004
Processing:     3  208 2942.9     51   60202
Waiting:        0  208 2942.9     51   60202
Total:         24  247 3153.2     51   63206

Percentage of the requests served within a certain time (ms)
  50%     51
  66%     52
  75%     52
  80%     52
  90%     53
  95%     54
  98%     55
  99%     61
 100%  63206 (longest request)
linux:~/ab/httpd-2.4.3/support$

1000 个并发

linux:~/ab/httpd-2.4.3/support$ ./ab -n 100000 -c 1000 http://localhost:8080/
This is ApacheBench, Version 2.3 <$Revision: 1373084 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking localhost (be patient)
Completed 10000 requests
Completed 20000 requests
Completed 30000 requests
Completed 40000 requests
Completed 50000 requests
Completed 60000 requests
Completed 70000 requests
Completed 80000 requests
Completed 90000 requests
Completed 100000 requests
Finished 100000 requests


Server Software:        
Server Hostname:        localhost
Server Port:            8080

Document Path:          /
Document Length:        18 bytes

Concurrency Level:      1000
Time taken for tests:   71.625 seconds
Complete requests:      100000
Failed requests:        0
Write errors:           0
Total transferred:      3700000 bytes
HTML transferred:       1800000 bytes
Requests per second:    1396.16 [#/sec] (mean)
Time per request:       716.252 [ms] (mean)
Time per request:       0.716 [ms] (mean, across all concurrent requests)
Transfer rate:          50.45 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0   68 628.8      0   21002
Processing:     1  442 4622.4     51   68587
Waiting:        0  442 4622.3     51   68587
Total:         17  510 4934.8     51   71588

Percentage of the requests served within a certain time (ms)
  50%     51
  66%     52
  75%     52
  80%     52
  90%     54
  95%     55
  98%     59
  99%   4107
 100%  71588 (longest request)
linux:~/ab/httpd-2.4.3/support$

再来是多线程

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <pthread.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>

#define BUFFER_SIZE 4096

int tcpSrv(int listen_port);
void* process_thread(void* sockfd);

int main(int argc, char** argv) {
    tcpSrv(8080);
    return 0;
}

void* process_thread(void* sockfd) {
    //printf("thread created\n");
    int connfd = *((int *)sockfd);
    char buff[BUFFER_SIZE+1];
    memset(&buff, 0, sizeof(buff));
    recv(connfd, buff, BUFFER_SIZE, 0);
    //printf("recv msg:\n%s\n", buff);
    char resp[] = "HTTP/1.0 200 OK\r\n\r\n<html>hello</html>";
    send(connfd, resp, strlen(resp), 0);
    close(connfd);
    //printf("thread about to exit\n");
    pthread_exit(NULL);
}

int tcpSrv(int listen_port) {
    int listenfd, connfd;
    struct sockaddr_in servaddr;

    if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
        printf("create socket error: %s(errno: %d)\n", strerror(errno), errno);
        return -1;
    }

    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    servaddr.sin_port = htons(listen_port);

    if (bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) == -1) {
        printf("bind socket error: %s(errno: %d)\n", strerror(errno), errno);
        close(listenfd);
        return -1;
    }

    if (listen(listenfd, 2048) == -1) {
        printf("listen socket error: %s(errno: %d)\n", strerror(errno), errno);
        close(listenfd);
        return -1;
    }

    printf("-----waiting for client's request-----\n");
    while (1) {
        if ((connfd = accept(listenfd, (struct sockaddr *)NULL, NULL)) == -1) {
            printf("accept socket error: %s(errno: %d)\n", strerror(errno), errno);
            close(listenfd);
            return -1;
        }
        //printf("main thread about to create thread\n");
        pthread_t tid;
        pthread_attr_t opt;
        pthread_attr_init(&opt);
        pthread_attr_setdetachstate(&opt, PTHREAD_CREATE_DETACHED);
        if (pthread_create(&tid, &opt, process_thread, &connfd) != 0) {
            printf("error line: %d\t", __LINE__);
            perror(__FILE__);
            return -1;
        }
        pthread_attr_destroy(&opt);
        //printf("main thread finish creating thread\n");
    }
    
    close(listenfd);
    return 0;
}

单并发

linux:~/ab/httpd-2.4.3/support$ ./ab -n 100000 -c 1 http://localhost:8080/123
This is ApacheBench, Version 2.3 <$Revision: 1373084 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking localhost (be patient)
Completed 10000 requests
Completed 20000 requests
Completed 30000 requests
Completed 40000 requests
Completed 50000 requests
Completed 60000 requests
Completed 70000 requests
Completed 80000 requests
Completed 90000 requests
Completed 100000 requests
Finished 100000 requests


Server Software:        
Server Hostname:        localhost
Server Port:            8080

Document Path:          /123
Document Length:        18 bytes

Concurrency Level:      1
Time taken for tests:   7.629 seconds
Complete requests:      100000
Failed requests:        0
Write errors:           0
Total transferred:      3700000 bytes
HTML transferred:       1800000 bytes
Requests per second:    13108.37 [#/sec] (mean)
Time per request:       0.076 [ms] (mean)
Time per request:       0.076 [ms] (mean, across all concurrent requests)
Transfer rate:          473.64 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    0   0.0      0       4
Processing:     0    0   0.1      0      24
Waiting:        0    0   0.1      0      23
Total:          0    0   0.1      0      24

Percentage of the requests served within a certain time (ms)
  50%      0
  66%      0
  75%      0
  80%      0
  90%      0
  95%      0
  98%      0
  99%      0
 100%     24 (longest request)
linux:~/ab/httpd-2.4.3/support$

10 个并发

linux:~/ab/httpd-2.4.3/support$ ./ab -n 100000 -c 10 http://localhost:8080/123
This is ApacheBench, Version 2.3 <$Revision: 1373084 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking localhost (be patient)
Completed 10000 requests
Completed 20000 requests
Completed 30000 requests
Completed 40000 requests
Completed 50000 requests
Completed 60000 requests
Completed 70000 requests
Completed 80000 requests
Completed 90000 requests
apr_pollset_poll: The timeout specified has expired (70007)
Total of 99991 requests completed
linux:~/ab/httpd-2.4.3/support$

至于 select 和 poll 就没有写了，直接写 epoll 模型

#include <iostream>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <errno.h>

using namespace std;

#define MAX_LINE 1024
#define OPEN_MAX 100
#define LISTENQ 1024
#define SERV_PORT 8080
#define INFTIM 1000
#define MAX_EVENTS 1024
#define EP_TIMEOUT 500

int tcpSrv(int listen_port);
int set_non_block(int fd);

int main(int argc, char* argv[]) {
    tcpSrv(SERV_PORT);
    return 0;
}

int set_non_block(int fd) {
    int fd_fl = fcntl(fd, F_GETFL); 
    fd_fl |= O_NONBLOCK;
    if (fcntl(fd, F_SETFL, fd_fl) < 0) {
        printf("%d\n:", __LINE__);perror(__FILE__);
        return -1;
    }
    return 0;
}

int tcpSrv(int listen_port) {
    int listenfd = socket(AF_INET, SOCK_STREAM, 0);
    if (-1 == listenfd) {
        printf("%d\n:", __LINE__);perror(__FILE__);
        return -1;
    }
    set_non_block(listenfd);

    struct epoll_event ev;
    ev.data.fd = listenfd;
    ev.events = EPOLLIN|EPOLLET;
    int epfd = epoll_create(4096);
    epoll_ctl(epfd, EPOLL_CTL_ADD, listenfd, &ev);

    struct sockaddr_in serveraddr;
    bzero(&serveraddr, sizeof(serveraddr));
    serveraddr.sin_family = AF_INET;
    char* local_addr = "127.0.0.1";
    inet_aton(local_addr, &(serveraddr.sin_addr));
    serveraddr.sin_port = htons(listen_port);

    if (bind(listenfd, (sockaddr*)&serveraddr, sizeof(serveraddr)) == -1) {
        printf("%d\n:", __LINE__);perror(__FILE__);
        close(listenfd);
        return -1;
    }
    
    if (listen(listenfd, LISTENQ) == -1) {
        printf("%d\n:", __LINE__);perror(__FILE__);
        close(listenfd);
        return -1;
    }

    struct epoll_event events[MAX_EVENTS];
    //struct sockaddr_in clientaddr;
    //socklen_t clilen;
    while (1) {
        int nfds = epoll_wait(epfd, events, MAX_EVENTS, EP_TIMEOUT);
        //printf("events count:%d\n", nfds);
        for (int i=0; i<nfds; i++) {
            if (events[i].data.fd == listenfd) {
                while (1) {
                    int connfd = accept(listenfd, NULL, NULL);
                    if (connfd < 0) {
                        //printf("%d\n:", __LINE__);perror(__FILE__);
                        break;
                    }
                    //char *str_client_addr = inet_ntoa(clientaddr.sin_addr);
                    //cout<<"accept a connection from: "<<str_client_addr<<endl;
                    ev.data.fd = connfd;
                    ev.events = EPOLLIN | EPOLLET;
                    epoll_ctl(epfd, EPOLL_CTL_ADD, connfd, &ev);
                }
            } else if (events[i].events & EPOLLIN) {
                //cout<<"EPOLLIN"<<endl;
                int sockfd = events[i].data.fd;
                if (sockfd < 0) {
                    printf("%d\n:", __LINE__);perror(__FILE__);
                    continue;
                }
                char buffer[MAX_LINE+1];
                memset(buffer, 0, sizeof(buffer));
                read(sockfd, buffer, MAX_LINE);
                //printf("%s\n", buffer);
                set_non_block(sockfd);
                char html_resp[] = "HTTP/1.1 200 OK\r\n\r\n<html>epoll</html>";
                write(sockfd, html_resp, strlen(html_resp));
                epoll_ctl(epfd, EPOLL_CTL_DEL, sockfd, NULL);
                close(sockfd);
            }
        }
    }
    
    return 0;
}

单并发

linux:~/ab/httpd-2.4.3/support$ ./ab -n 100000 -c 1 http://localhost:8080/123
This is ApacheBench, Version 2.3 <$Revision: 1373084 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking localhost (be patient)
Completed 10000 requests
Completed 20000 requests
Completed 30000 requests
Completed 40000 requests
Completed 50000 requests
Completed 60000 requests
Completed 70000 requests
Completed 80000 requests
Completed 90000 requests
Completed 100000 requests
Finished 100000 requests


Server Software:        
Server Hostname:        localhost
Server Port:            8080

Document Path:          /123
Document Length:        18 bytes

Concurrency Level:      1
Time taken for tests:   7.474 seconds
Complete requests:      100000
Failed requests:        0
Write errors:           0
Total transferred:      3700000 bytes
HTML transferred:       1800000 bytes
Requests per second:    13380.33 [#/sec] (mean)
Time per request:       0.075 [ms] (mean)
Time per request:       0.075 [ms] (mean, across all concurrent requests)
Transfer rate:          483.47 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    0   0.0      0       4
Processing:     0    0   0.0      0       5
Waiting:        0    0   0.0      0       5
Total:          0    0   0.0      0       5

Percentage of the requests served within a certain time (ms)
  50%      0
  66%      0
  75%      0
  80%      0
  90%      0
  95%      0
  98%      0
  99%      0
 100%      5 (longest request)

10 个并发

linux:~/ab/httpd-2.4.3/support$ ./ab -n 100000 -c 10 http://localhost:8080/123
This is ApacheBench, Version 2.3 <$Revision: 1373084 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking localhost (be patient)
Completed 10000 requests
Completed 20000 requests
Completed 30000 requests
Completed 40000 requests
Completed 50000 requests
Completed 60000 requests
Completed 70000 requests
Completed 80000 requests
Completed 90000 requests
Completed 100000 requests
Finished 100000 requests


Server Software:        
Server Hostname:        localhost
Server Port:            8080

Document Path:          /123
Document Length:        18 bytes

Concurrency Level:      10
Time taken for tests:   5.991 seconds
Complete requests:      100000
Failed requests:        0
Write errors:           0
Total transferred:      3700000 bytes
HTML transferred:       1800000 bytes
Requests per second:    16691.90 [#/sec] (mean)
Time per request:       0.599 [ms] (mean)
Time per request:       0.060 [ms] (mean, across all concurrent requests)
Transfer rate:          603.13 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    0   0.1      0       6
Processing:     0    0   0.1      0       7
Waiting:        0    0   0.1      0       6
Total:          0    1   0.2      1       7

Percentage of the requests served within a certain time (ms)
  50%      1
  66%      1
  75%      1
  80%      1
  90%      1
  95%      1
  98%      1
  99%      1
 100%      7 (longest request)

100 个并发

linux:~/ab/httpd-2.4.3/support$ ./ab -n 100000 -c 100 http://localhost:8080/123
This is ApacheBench, Version 2.3 <$Revision: 1373084 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking localhost (be patient)
Completed 10000 requests
Completed 20000 requests
Completed 30000 requests
Completed 40000 requests
Completed 50000 requests
Completed 60000 requests
Completed 70000 requests
Completed 80000 requests
Completed 90000 requests
Completed 100000 requests
Finished 100000 requests


Server Software:        
Server Hostname:        localhost
Server Port:            8080

Document Path:          /123
Document Length:        18 bytes

Concurrency Level:      100
Time taken for tests:   6.233 seconds
Complete requests:      100000
Failed requests:        0
Write errors:           0
Total transferred:      3700000 bytes
HTML transferred:       1800000 bytes
Requests per second:    16043.99 [#/sec] (mean)
Time per request:       6.233 [ms] (mean)
Time per request:       0.062 [ms] (mean, across all concurrent requests)
Transfer rate:          579.71 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    1   1.0      1       9
Processing:     1    5   0.9      5      12
Waiting:        1    2   0.9      2      10
Total:          2    6   1.4      6      15

Percentage of the requests served within a certain time (ms)
  50%      6
  66%      7
  75%      7
  80%      7
  90%      8
  95%      8
  98%     10
  99%     10
 100%     15 (longest request)

1000 个并发

linux:~/ab/httpd-2.4.3/support$ ./ab -n 100000 -c 1000 http://localhost:8080/123
This is ApacheBench, Version 2.3 <$Revision: 1373084 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking localhost (be patient)
Completed 10000 requests
Completed 20000 requests
Completed 30000 requests
Completed 40000 requests
Completed 50000 requests
Completed 60000 requests
Completed 70000 requests
Completed 80000 requests
Completed 90000 requests
Completed 100000 requests
Finished 100000 requests


Server Software:        
Server Hostname:        localhost
Server Port:            8080

Document Path:          /123
Document Length:        18 bytes

Concurrency Level:      1000
Time taken for tests:   7.099 seconds
Complete requests:      100000
Failed requests:        0
Write errors:           0
Total transferred:      3700000 bytes
HTML transferred:       1800000 bytes
Requests per second:    14087.17 [#/sec] (mean)
Time per request:       70.987 [ms] (mean)
Time per request:       0.071 [ms] (mean, across all concurrent requests)
Transfer rate:          509.01 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        1   26 115.1     19    3054
Processing:    16   44   9.7     43      76
Waiting:        1   18   8.0     18      54
Total:         20   70 115.7     65    3103

Percentage of the requests served within a certain time (ms)
  50%     65
  66%     73
  75%     79
  80%     82
  90%     89
  95%     95
  98%    101
  99%    106
 100%   3103 (longest request)
linux:~/ab/httpd-2.4.3/support$

可以看到 epoll 确实是很猛的，这里有一个地方需要注意，我调了两天，就是在 epoll 的 EPOLLIN 事件发生在 listenfd 上的时候，这个时候需要去 accept，这个应该都没有什么问题，但是我一开始只是 accept 了一个，而实际上，这个时候，是可能有多个连接在等待 accept 的，于是就导致了并发能力很不行，正确的做法应该是一直 accept，直到没有东西可以 accept 了，这样才能有并发能力。

shell 俄罗斯方块

Tue, 05 Feb 2013 15:51:21 +0800

利用 bash 脚本在 shell 上跑一个俄罗斯方块的游戏，还是挺有意思的，视频讲解在这里，http://v.youku.com/v_show/id_XMzc2Mjg5MTg0.html，http://v.youku.com/v_show/id_XMzc2MzExNzc2.html，代码的话这里有一份，http://www.chinaunix.net/old_jh/24/184858.html，原样照搬过来

#!/bin/bash

# Tetris Game
# 10.21.2003 xhchen<[email]xhchen@winbond.com.tw[/email]>

#APP declaration
APP_NAME="${0##*[\\/]}"
APP_VERSION="1.0"


#颜色定义
cRed=1
cGreen=2
cYellow=3
cBlue=4
cFuchsia=5
cCyan=6
cWhite=7
colorTable=($cRed $cGreen $cYellow $cBlue $cFuchsia $cCyan $cWhite)

#位置和大小
iLeft=3
iTop=2
((iTrayLeft = iLeft + 2))
((iTrayTop = iTop + 1))
((iTrayWidth = 10))
((iTrayHeight = 15))

#颜色设置
cBorder=$cGreen
cScore=$cFuchsia
cScoreValue=$cCyan

#控制信号
#改游戏使用两个进程，一个用于接收输入，一个用于游戏流程和显示界面;
#当前者接收到上下左右等按键时，通过向后者发送signal的方式通知后者。
sigRotate=25
sigLeft=26
sigRight=27
sigDown=28
sigAllDown=29
sigExit=30

#七中不同的方块的定义
#通过旋转，每种方块的显示的样式可能有几种
box0=(0 0 0 1 1 0 1 1)
box1=(0 2 1 2 2 2 3 2 1 0 1 1 1 2 1 3)
box2=(0 0 0 1 1 1 1 2 0 1 1 0 1 1 2 0)
box3=(0 1 0 2 1 0 1 1 0 0 1 0 1 1 2 1)
box4=(0 1 0 2 1 1 2 1 1 0 1 1 1 2 2 2 0 1 1 1 2 0 2 1 0 0 1 0 1 1 1 2)
box5=(0 1 1 1 2 1 2 2 1 0 1 1 1 2 2 0 0 0 0 1 1 1 2 1 0 2 1 0 1 1 1 2)
box6=(0 1 1 1 1 2 2 1 1 0 1 1 1 2 2 1 0 1 1 0 1 1 2 1 0 1 1 0 1 1 1 2)
#所有其中方块的定义都放到box变量中
box=(${box0[@]} ${box1[@]} ${box2[@]} ${box3[@]} ${box4[@]} ${box5[@]} ${box6[@]})
#各种方块旋转后可能的样式数目
countBox=(1 2 2 2 4 4 4)
#各种方块再box数组中的偏移
offsetBox=(0 1 3 5 7 11 15)

#每提高一个速度级需要积累的分数
iScoreEachLevel=50	#be greater than 7

#运行时数据
sig=0		#接收到的signal
iScore=0	#总分
iLevel=0	#速度级
boxNew=()	#新下落的方块的位置定义
cBoxNew=0	#新下落的方块的颜色
iBoxNewType=0	#新下落的方块的种类
iBoxNewRotate=0	#新下落的方块的旋转角度
boxCur=()	#当前方块的位置定义
cBoxCur=0	#当前方块的颜色
iBoxCurType=0	#当前方块的种类
iBoxCurRotate=0	#当前方块的旋转角度
boxCurX=-1	#当前方块的x坐标位置
boxCurY=-1	#当前方块的y坐标位置
iMap=()		#背景方块图表

#初始化所有背景方块为-1, 表示没有方块
for ((i = 0; i < iTrayHeight * iTrayWidth; i++)); do iMap[$i]=-1; done


#接收输入的进程的主函数
function RunAsKeyReceiver()
{
	local pidDisplayer key aKey sig cESC sTTY

	pidDisplayer=$1
	aKey=(0 0 0)

	cESC=`echo -ne "\033"`
	cSpace=`echo -ne "\040"`

	#保存终端属性。在read -s读取终端键时，终端的属性会被暂时改变。
	#如果在read -s时程序被不幸杀掉，可能会导致终端混乱，
	#需要在程序退出时恢复终端属性。
	sTTY=`stty -g`

	#捕捉退出信号
	trap "MyExit;" INT TERM
	trap "MyExitNoSub;" $sigExit

	#隐藏光标
	echo -ne "\033[?25l"


	while :
	do
		#读取输入。注-s不回显，-n读到一个字符立即返回
		read -s -n 1 key

		aKey[0]=${aKey[1]}
		aKey[1]=${aKey[2]}
		aKey[2]=$key
		sig=0

		#判断输入了何种键
		if [[ $key == $cESC && ${aKey[1]} == $cESC ]]
		then
			#ESC键
			MyExit
		elif [[ ${aKey[0]} == $cESC && ${aKey[1]} == "[" ]]
		then
			if [[ $key == "A" ]]; then sig=$sigRotate	#<向上键>
			elif [[ $key == "B" ]]; then sig=$sigDown	#<向下键>
			elif [[ $key == "D" ]]; then sig=$sigLeft	#<向左键>
			elif [[ $key == "C" ]]; then sig=$sigRight	#<向右键>
			fi
		elif [[ $key == "W" || $key == "w" ]]; then sig=$sigRotate	#W, w
		elif [[ $key == "S" || $key == "s" ]]; then sig=$sigDown	#S, s
		elif [[ $key == "A" || $key == "a" ]]; then sig=$sigLeft	#A, a
		elif [[ $key == "D" || $key == "d" ]]; then sig=$sigRight	#D, d
		elif [[ "[$key]" == "[]" ]]; then sig=$sigAllDown	#空格键
		elif [[ $key == "Q" || $key == "q" ]]			#Q, q
		then
			MyExit
		fi

		if [[ $sig != 0 ]]
		then
			#向另一进程发送消息
			kill -$sig $pidDisplayer
		fi
	done
}

#退出前的恢复
function MyExitNoSub()
{
	local y

	#恢复终端属性
	stty $sTTY
	((y = iTop + iTrayHeight + 4))

	#显示光标
	echo -e "\033[?25h\033[${y};0H"
	exit
}


function MyExit()
{
	#通知显示进程需要退出
	kill -$sigExit $pidDisplayer

	MyExitNoSub
}


#处理显示和游戏流程的主函数
function RunAsDisplayer()
{
	local sigThis
	InitDraw

	#挂载各种信号的处理函数
	trap "sig=$sigRotate;" $sigRotate
	trap "sig=$sigLeft;" $sigLeft
	trap "sig=$sigRight;" $sigRight
	trap "sig=$sigDown;" $sigDown
	trap "sig=$sigAllDown;" $sigAllDown
	trap "ShowExit;" $sigExit

	while :
	do
		#根据当前的速度级iLevel不同，设定相应的循环的次数
		for ((i = 0; i < 21 - iLevel; i++))
		do
			sleep 0.02
			sigThis=$sig
			sig=0

			#根据sig变量判断是否接受到相应的信号
			if ((sigThis == sigRotate)); then BoxRotate;	#旋转
			elif ((sigThis == sigLeft)); then BoxLeft;	#左移一列
			elif ((sigThis == sigRight)); then BoxRight;	#右移一列
			elif ((sigThis == sigDown)); then BoxDown;	#下落一行
			elif ((sigThis == sigAllDown)); then BoxAllDown;	#下落到底
			fi
		done
		#kill -$sigDown $$
		BoxDown	#下落一行
	done
}


#BoxMove(y, x), 测试是否可以把移动中的方块移到(x, y)的位置, 返回0则可以, 1不可以
function BoxMove()
{
	local j i x y xTest yTest
	yTest=$1
	xTest=$2
	for ((j = 0; j < 8; j += 2))
	do
		((i = j + 1))
		((y = ${boxCur[$j]} + yTest))
		((x = ${boxCur[$i]} + xTest))
		if (( y < 0 || y >= iTrayHeight || x < 0 || x >= iTrayWidth))
		then
			#撞到墙壁了
			return 1
		fi
		if ((${iMap[y * iTrayWidth + x]} != -1 ))
		then
			#撞到其他已经存在的方块了
			return 1
		fi
	done
	return 0;
}


#将当前移动中的方块放到背景方块中去,
#并计算新的分数和速度级。(即一次方块落到底部)
function Box2Map()
{
	local j i x y xp yp line

	#将当前移动中的方块放到背景方块中去
	for ((j = 0; j < 8; j += 2))
	do
		((i = j + 1))
		((y = ${boxCur[$j]} + boxCurY))
		((x = ${boxCur[$i]} + boxCurX))
		((i = y * iTrayWidth + x))
		iMap[$i]=$cBoxCur
	done

	#消去可被消去的行
	line=0
	for ((j = 0; j < iTrayWidth * iTrayHeight; j += iTrayWidth))
	do
		for ((i = j + iTrayWidth - 1; i >= j; i--))
		do
			if ((${iMap[$i]} == -1)); then break; fi
		done
		if ((i >= j)); then continue; fi

		((line++))
		for ((i = j - 1; i >= 0; i--))
		do
			((x = i + iTrayWidth))
			iMap[$x]=${iMap[$i]}
		done
		for ((i = 0; i < iTrayWidth; i++))
		do
			iMap[$i]=-1
		done
	done

	if ((line == 0)); then return; fi

	#根据消去的行数line计算分数和速度级
	((x = iLeft + iTrayWidth * 2 + 7))
	((y = iTop + 11))
	((iScore += line * 2 - 1))
	#显示新的分数
	echo -ne "\033[1m\033[3${cScoreValue}m\033[${y};${x}H${iScore}         "
	if ((iScore % iScoreEachLevel < line * 2 - 1))
	then
		if ((iLevel < 20))
		then
			((iLevel++))
			((y = iTop + 14))
			#显示新的速度级
			echo -ne "\033[3${cScoreValue}m\033[${y};${x}H${iLevel}        "
		fi
	fi
	echo -ne "\033[0m"


	#重新显示背景方块
	for ((y = 0; y < iTrayHeight; y++))
	do
		((yp = y + iTrayTop + 1))
		((xp = iTrayLeft + 1))
		((i = y * iTrayWidth))
		echo -ne "\033[${yp};${xp}H"
		for ((x = 0; x < iTrayWidth; x++))
		do
			((j = i + x))
			if ((${iMap[$j]} == -1))
			then
				echo -ne "  "
			else
				echo -ne "\033[1m\033[7m\033[3${iMap[$j]}m\033[4${iMap[$j]}m[]\033[0m"
			fi
		done
	done
}


#下落一行
function BoxDown()
{
	local y s
	((y = boxCurY + 1))	#新的y坐标
	if BoxMove $y $boxCurX	#测试是否可以下落一行
	then
		s="`DrawCurBox 0`"	#将旧的方块抹去
		((boxCurY = y))
		s="$s`DrawCurBox 1`"	#显示新的下落后方块
		echo -ne $s
	else
		#走到这儿, 如果不能下落了
		Box2Map		#将当前移动中的方块贴到背景方块中
		RandomBox	#产生新的方块
	fi
}

#左移一列
function BoxLeft()
{
	local x s
	((x = boxCurX - 1))
	if BoxMove $boxCurY $x
	then
		s=`DrawCurBox 0`
		((boxCurX = x))
		s=$s`DrawCurBox 1`
		echo -ne $s
	fi
}

#右移一列
function BoxRight()
{
	local x s
	((x = boxCurX + 1))
	if BoxMove $boxCurY $x
	then
		s=`DrawCurBox 0`
		((boxCurX = x))
		s=$s`DrawCurBox 1`
		echo -ne $s
	fi
}


#下落到底
function BoxAllDown()
{
	local k j i x y iDown s
	iDown=$iTrayHeight

	#计算一共需要下落多少行
	for ((j = 0; j < 8; j += 2))
	do
		((i = j + 1))
		((y = ${boxCur[$j]} + boxCurY))
		((x = ${boxCur[$i]} + boxCurX))
		for ((k = y + 1; k < iTrayHeight; k++))
		do
			((i = k * iTrayWidth + x))
			if (( ${iMap[$i]} != -1)); then break; fi
		done
		((k -= y + 1))
		if (( $iDown > $k )); then iDown=$k; fi
	done

	s=`DrawCurBox 0`	#将旧的方块抹去
	((boxCurY += iDown))
	s=$s`DrawCurBox 1`	#显示新的下落后的方块
	echo -ne $s
	Box2Map		#将当前移动中的方块贴到背景方块中
	RandomBox	#产生新的方块
}


#旋转方块
function BoxRotate()
{
	local iCount iTestRotate boxTest j i s
	iCount=${countBox[$iBoxCurType]}	#当前的方块经旋转可以产生的样式的数目

	#计算旋转后的新的样式
	((iTestRotate = iBoxCurRotate + 1))
	if ((iTestRotate >= iCount))
	then
		((iTestRotate = 0))
	fi

	#更新到新的样式, 保存老的样式(但不显示)
	for ((j = 0, i = (${offsetBox[$iBoxCurType]} + $iTestRotate) * 8; j < 8; j++, i++))
	do
		boxTest[$j]=${boxCur[$j]}
		boxCur[$j]=${box[$i]}
	done

	if BoxMove $boxCurY $boxCurX	#测试旋转后是否有空间放的下
	then
		#抹去旧的方块
		for ((j = 0; j < 8; j++))
		do
			boxCur[$j]=${boxTest[$j]}
		done
		s=`DrawCurBox 0`

		#画上新的方块
		for ((j = 0, i = (${offsetBox[$iBoxCurType]} + $iTestRotate) * 8; j < 8; j++, i++))
		do
			boxCur[$j]=${box[$i]}
		done
		s=$s`DrawCurBox 1`
		echo -ne $s
		iBoxCurRotate=$iTestRotate
	else
		#不能旋转，还是继续使用老的样式
		for ((j = 0; j < 8; j++))
		do
			boxCur[$j]=${boxTest[$j]}
		done
	fi
}


#DrawCurBox(bDraw), 绘制当前移动中的方块, bDraw为1, 画上, bDraw为0, 抹去方块。
function DrawCurBox()
{
	local i j t bDraw sBox s
	bDraw=$1

	s=""
	if (( bDraw == 0 ))
	then
		sBox="\040\040"
	else
		sBox="[]"
		s=$s"\033[1m\033[7m\033[3${cBoxCur}m\033[4${cBoxCur}m"
	fi

	for ((j = 0; j < 8; j += 2))
	do
		((i = iTrayTop + 1 + ${boxCur[$j]} + boxCurY))
		((t = iTrayLeft + 1 + 2 * (boxCurX + ${boxCur[$j + 1]})))
		#\033[y;xH, 光标到(x, y)处
		s=$s"\033[${i};${t}H${sBox}"
	done
	s=$s"\033[0m"
	echo -n $s
}


#更新新的方块
function RandomBox()
{
	local i j t

	#更新当前移动的方块
	iBoxCurType=${iBoxNewType}
	iBoxCurRotate=${iBoxNewRotate}
	cBoxCur=${cBoxNew}
	for ((j = 0; j < ${#boxNew[@]}; j++))
	do
		boxCur[$j]=${boxNew[$j]}
	done


	#显示当前移动的方块
	if (( ${#boxCur[@]} == 8 ))
	then
		#计算当前方块该从顶端哪一行"冒"出来
		for ((j = 0, t = 4; j < 8; j += 2))
		do
			if ((${boxCur[$j]} < t)); then t=${boxCur[$j]}; fi
		done
		((boxCurY = -t))
		for ((j = 1, i = -4, t = 20; j < 8; j += 2))
		do
			if ((${boxCur[$j]} > i)); then i=${boxCur[$j]}; fi
			if ((${boxCur[$j]} < t)); then t=${boxCur[$j]}; fi
		done
		((boxCurX = (iTrayWidth - 1 - i - t) / 2))

		#显示当前移动的方块
		echo -ne `DrawCurBox 1`

		#如果方块一出来就没处放，Game over!
		if ! BoxMove $boxCurY $boxCurX
		then
			kill -$sigExit ${PPID}
			ShowExit
		fi
	fi



	#清除右边预显示的方块
	for ((j = 0; j < 4; j++))
	do
		((i = iTop + 1 + j))
		((t = iLeft + 2 * iTrayWidth + 7))
		echo -ne "\033[${i};${t}H        "
	done

	#随机产生新的方块
	((iBoxNewType = RANDOM % ${#offsetBox[@]}))
	((iBoxNewRotate = RANDOM % ${countBox[$iBoxNewType]}))
	for ((j = 0, i = (${offsetBox[$iBoxNewType]} + $iBoxNewRotate) * 8; j < 8; j++, i++))
	do
		boxNew[$j]=${box[$i]};
	done

	((cBoxNew = ${colorTable[RANDOM % ${#colorTable[@]}]}))

	#显示右边预显示的方块
	echo -ne "\033[1m\033[7m\033[3${cBoxNew}m\033[4${cBoxNew}m"
	for ((j = 0; j < 8; j += 2))
	do
		((i = iTop + 1 + ${boxNew[$j]}))
		((t = iLeft + 2 * iTrayWidth + 7 + 2 * ${boxNew[$j + 1]}))
		echo -ne "\033[${i};${t}H[]"
	done
	echo -ne "\033[0m"
}


#初始绘制
function InitDraw()
{
	clear
	RandomBox	#随机产生方块，这时右边预显示窗口中有方快了
	RandomBox	#再随机产生方块，右边预显示窗口中的方块被更新，原先的方块将开始下落
	local i t1 t2 t3

	#显示边框
	echo -ne "\033[1m"
	echo -ne "\033[3${cBorder}m\033[4${cBorder}m"

	((t2 = iLeft + 1))
	((t3 = iLeft + iTrayWidth * 2 + 3))
	for ((i = 0; i < iTrayHeight; i++))
	do
		((t1 = i + iTop + 2))
		echo -ne "\033[${t1};${t2}H||"
		echo -ne "\033[${t1};${t3}H||"
	done

	((t2 = iTop + iTrayHeight + 2))
	for ((i = 0; i < iTrayWidth + 2; i++))
	do
		((t1 = i * 2 + iLeft + 1))
		echo -ne "\033[${iTrayTop};${t1}H=="
		echo -ne "\033[${t2};${t1}H=="
	done
	echo -ne "\033[0m"


	#显示"Score"和"Level"字样
	echo -ne "\033[1m"
	((t1 = iLeft + iTrayWidth * 2 + 7))
	((t2 = iTop + 10))
	echo -ne "\033[3${cScore}m\033[${t2};${t1}HScore"
	((t2 = iTop + 11))
	echo -ne "\033[3${cScoreValue}m\033[${t2};${t1}H${iScore}"
	((t2 = iTop + 13))
	echo -ne "\033[3${cScore}m\033[${t2};${t1}HLevel"
	((t2 = iTop + 14))
	echo -ne "\033[3${cScoreValue}m\033[${t2};${t1}H${iLevel}"
	echo -ne "\033[0m"
}


#退出时显示GameOVer!
function ShowExit()
{
	local y
	((y = iTrayHeight + iTrayTop + 3))
	echo -e "\033[${y};0HGameOver!\033[0m"
	exit
}


#显示用法.
function Usage
{
	cat << EOF
Usage: $APP_NAME
Start tetris game.

  -h, --help              display this help and exit
      --version           output version information and exit
EOF
}


#游戏主程序在这儿开始.
if [[ "$1" == "-h" || "$1" == "--help" ]]; then
	Usage
elif [[ "$1" == "--version" ]]; then
	echo "$APP_NAME $APP_VERSION"
elif [[ "$1" == "--show" ]]; then
	#当发现具有参数--show时，运行显示函数
	RunAsDisplayer
else
	bash $0 --show&	#以参数--show将本程序再运行一遍
	RunAsKeyReceiver $!	#以上一行产生的进程的进程号作为参数
fi

二级指针删除单向链表

Mon, 04 Feb 2013 23:22:29 +0800

今晚在这里看到一篇文章，http://coolshell.cn/articles/8990.html，原文给的是代码片段，本着动手实践的原则，另外顺便复习一下链表，写了下代码

#include <stdio.h>
#include <stdlib.h>

typedef struct _node {
	int n;
	struct _node *next;
} node;

typedef int (* remove_fn)(node const *n);

node *create_link();
void destory_link(node *head);
void print_link(node *head);
int should_remove(node const *n);
node *remove_if(node *head, remove_fn should_remove);
void remove_if2(node **head, remove_fn should_remove);

int main() {
	node *head = create_link();
	print_link(head);
	//head = remove_if(head, should_remove);
	remove_if2(&head, should_remove);
	print_link(head);
	destory_link(head);
	return 0;
}

node *create_link() {
	node *head = malloc(sizeof(node));
	if (head == NULL) {
		printf("malloc head failed\n");
		return NULL;
	}
	head->n = 0;
	head->next = NULL;

	node *pre = head;
	for (int i=1; i<10; i++) {
		node *cur = malloc(sizeof(node));
		if (cur == NULL) {
			printf("malloc node %d failed\n", i);
			return NULL;
		}
		pre->next = cur;
		cur->n = i;
		cur->next = NULL;
		pre = cur;
	}

	return head;
}

void destory_link(node *head) {
	node *cur = head;
	while (cur) {
		node *next = cur->next;
		free(cur);
		cur = next;
	}
}

void print_link(node *head) {
	node *cur = head;
	while (cur) {
		printf("%d\t", cur->n);
		cur = cur->next;
	}
	printf("\n");
}

int should_remove(node const *n) {
	if (n == NULL) {
		return 0;
	}
	return (n->n)%2 == 0;
}

node *remove_if(node *head, remove_fn should_remove) {
	for (node *pre = NULL, *cur = head; cur;) {
		node * const next = cur->next;
		if (should_remove(cur)) {
			if (pre) {
				pre->next= next;
			} else {
				head = next;
			}
			free(cur);
		} else {
			pre = cur;
		}
		cur = next;
	}
	return head;
}

void remove_if2(node **head, remove_fn should_remove) {
	for (node **cur = head; *cur;) {
		node *entry = *cur;
		if (should_remove(entry)) {
			*cur = entry->next;
			free(entry);
		} else {
			cur = &(entry->next);
		}
	}
}

编译运行一下

zrj@zrj-desktop:~/c$ gcc -g -std=gnu99 link.c && ./a.out
0    1    2    3    4    5    6    7    8    9
1    3    5    7    9

其实道理不复杂，自己多读两遍代码就懂了，不得不承认这种写法确实很巧妙，而且就可读性来说，其实也没有下降多少

signal 在 c99 下的差异

Thu, 31 Jan 2013 10:24:33 +0800

在写一个 minishell 的时候，需要捕捉从键盘输入的 ctrl+c 产生的 SIGINT 信号，转入自己的处理函数，代码大致如下

#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <signal.h>

int shell_loop() {
    setup();
    COMBINE_COMMAND cmd;
    while (1) {
        init_cmd(&cmd);
        if (read_cmd(&cmd) == -1) {
            break;
        }
        if (strlen(cmd.cmd_line) == 0) {
            clean_up_cmd(&cmd);
            continue;
        }
        parse_cmd(&cmd);
        // print_cmd(&cmd);
        execute_cmd(&cmd);
        clean_up_cmd(&cmd);
    }
    return 0;
}

void setup() {
    signal(SIGINT, sigint_handler);
    signal(SIGQUIT, SIG_IGN);
}

void sigint_handler(int sig) {
    printf("\n[minishell]$ ");
    fflush(stdout);
}

在 make 编译的时候没有问题，但是调试执行的时候结果一直不对，按下 ctrl+c 之后依然退出了程序，怎么调试都不行，于是索性单独新建了一个文件夹，在里面写了一份测试代码

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>

void init2();
void handler(int sig);

int main() {
    signal(SIGINT, handler);
    char line[1024];
    while (fgets(line, 1024, stdin) != NULL) {
        init2();
    }
    return 0;
}

void init2() {
    printf("hello");
    fflush(stdout);
}

void handler(int sig) {
    init2();
}

然后编译执行

zrj@vm:~/c/test$ gcc main.c 
zrj@vm:~/c/test$ ./a.out 

hello
hello
hello^Chello^Chello^Chello
hello
hello
hellozrj@vm:~/c/test$

发现是没有任何问题的，一切都按照预期的方式去跑，于是回头去看原来的代码，但是怎么对比都没有发现哪里出问题，到最后几乎要把原来的代码都差不多注视光了，还是没有找到问题所在，这个时候突然想起 Makefile 来，于是看回原来工程的 Makefile，是这样的

.PHONY:clean
CC=gcc
CFLAGS=-Wall -g -std=c99
BIN=minishell
OBJS=main.o str.o shell.o
$(BIN):$(OBJS)
	$(CC) $(CFLAGS) $^ -o $@
%.o:%.c
	$(CC) $(CFLAGS) -c $< -o $@
clean:
	rm -f *.o $(BIN)

注意到第三行的编译参数中有使用了 c99，于是尝试去掉这个东西，再次编译，报一些语法错，主要是用到这个语法，

for (int i=0; i<count; i++)

，把这些文件暂时从 Makefile 中去掉，再编译，能够通过，再执行，于是就发现没有问题了，信号能够正常的捕捉并处理，于是知道是 c99 的问题

google 搜了一下，找到这里，http://forums.debian.net/viewtopic.php?t=6408

I continue my monologue. Thanks for listening.The solution to my problem seems to be simply the following:

Executive summary: use -std=gnu99 on linux if you need some C99 functions (e.g. strtof) but also want to use functions like sigaction and strtok_r

gcc on linux is stricter than gcc on FreeBSD (or icc on either FreeBSD or linux) concerning standards. gcc -std=c99 on linux means: *only* recognize functions specified in the standard (no sigaction, no strtok_r etc) gcc -std=c99 on FreeBSD or icc -std=c99 on either FreeBSD or linux means recognize functions specified in the standard. This corresponds more or less to -std=gnu99 on linux

PS. This trap seems to be quite common (e.g. discussions on debian-glibc about the “fact” that strtof is completely broken on linux). I would be grateful if somebody could point me to a good overview describing what standards compliance means for various OS/compiler+options/standards combinations.

于是把 c99 改成 gnu99 ，问题得到解决

另外这里也有讨论，http://stackoverflow.com/questions/8288164/signals-c99-vs-gnu99

Use sigaction(2) rather than signal(2).

The Linux man page has this, in particular, in the Portability section:

In the original UNIX systems, when a handler that was established using signal() was invoked by the delivery of a signal, the disposition of the signal would be reset to SIG_DFL, and the system did not block delivery of further instances of the signal. System V also provides these semantics for signal(). This was bad because the signal might be delivered again before the handler had a chance to reestablish itself. Furthermore, rapid deliveries of the same signal could result in recursive invocations of the handler.

BSD improved on this situation by changing the semantics of signal handling (but, unfortunately, silently changed the semantics when establishing a handler with signal()). On BSD, when a signal handler is invoked, the signal disposition is not reset, and further instances of the signal are blocked from being delivered while the handler is executing.

The situation on Linux is as follows:

The kernel’s signal() system call provides System V semantics.

By default, in glibc 2 and later, the signal() wrapper function does not invoke the kernel system call. Instead, it calls sigaction(2) using flags that supply BSD semantics. This default behav‐ ior is provided as long as the _BSD_SOURCE feature test macro is defined. By default, _BSD_SOURCE is defined; it is also implicitly defined if one defines _GNU_SOURCE, and can of course be explic‐ itly defined. On glibc 2 and later, if the _BSD_SOURCE feature test macro is not defined, then signal() provides System V semantics. (The default implicit definition of _BSD_SOURCE is not provided if one invokes gcc(1) in one of its standard modes (-std=xxx or -ansi) or defines various other feature test macros such as _POSIX_SOURCE, _XOPEN_SOURCE, or _SVID_SOURCE; see feature_test_macros(7).)

Using std=gnu99, you’re getting BSD semantics. Using -std=c99, you’re getting System V semantics. So the signal handler is “reinstalled” in one case (BSD), and the signal disposition is reset back to SIG_DFL in the other (System V).

pipe 函数产生的文件描述符

Wed, 30 Jan 2013 15:41:23 +0800

我们知道 pipe 可以产生一对管道，用于两个进程之间的单工通信，今天在接触一个代码的时候，发现他有一个做法：为每个进程都准备读写管道的文件描述符，同时，赋初始值为 0 和 1，然后根据需要，再进行或者不进行 pipe 管道的创建，之后进行一些业务逻辑，在后面，进行一个硬编码的比较：如果该进程的管道文件描述符为 0 或者 1，就不做操作，反之如果不是这两个值，就认为是生成的管道描述符，并调用 close 函数进行关闭。

这自然让人出现一个疑问，那就是 pipe 产生的文件描述符会不会可能刚好就是 0 或者 1 呢，动手实验一下

for (int i = 0; i < 10; ++i)
{
    int fds[2];
    pipe(fds);
    printf("%d\n", fds[0]);
    printf("%d\n", fds[1]);
}

输出是这样的

看来 pipe 在实现的时候就已经有所保留了

==========================================

2013-01-30 15:53:00 update 在查阅资料的时候发现这里，http://www.cnblogs.com/jht/archive/2006/04/04/366086.html

dup,dup2函数

这两个函数的功能是输出的重定向定义这两个函数的头文件是unistd.h，有兴趣的可以自己看看这个头文件包含的内容要提的是这个头文件同时定义了下面三个常量 STDERR_FILENO = 2 标准错误输出 STDIN_FILENO = 0 标准输入 STDOUT_FILENO = 1 标准输出

在 HTTP 协议下分段下载文件

Thu, 04 Oct 2012 22:15:10 +0800

最近想要搞一个 linux 下的多线程下载工具，就像 wget 那样可以，只不过是多线程的，其中遇到一个问题，就是 http 如何分段下载，查找资料最后看到这里，http://www.rosoo.net/a/201006/9570.html

假如一个文件有1000个字节，那么其范围就是0-999，则： Range: bytes=500- 表示读取该文件的500-999字节，共500字节。 Range: bytes=500-599 表示读取该文件的500-599字节，共100字节。 Range还有其它几种写法，但上面这两种是最常用的，对于断点续传也足矣了。如果HTTP请求中包含Range字段，那么服务器会返回206（Partial Content），同时HTTP头中也会有一个相应的Content-Range字段，类似下面的格式： Content-Range: bytes 500-999/1000 Content-Range字段说明服务器返回了文件的某个范围及文件的总长度。这时Content-Length字段就不是整个文件的大小了，而是对应文件这个范围的字节数，这一点一定要注意。

他原文是用来做断点续传的，不过用来做多线程下载也是一样的道理

linux 下 fork 后的文件资源处理问题

Tue, 02 Oct 2012 16:47:32 +0800

我们都知道 linux 下 fork 一个子进程出来，他能够继承父进程的文件资源，网络资源等，也从父进程那里拷贝了代码段，数据段，缓冲区等等到自己这里有了新的一份，那么，如果父子进程对于打开的文件资源操作不同，会是怎样的结果呢，先看正常的使用代码

#include <stdio.h>
#include <unistd.h>

int main(int argc, char **argv) {
    FILE *fp;
    if ((fp=fopen("test.out", "w+")) == NULL) {
        printf("open file failedn");
        return -1;
    }
    fprintf(fp, "hello worldn");

    pid_t fpid;
    fpid = fork();
    if (fpid < 0) {
        printf("error in forkn");
        return -1;
    } else if (fpid == 0) {
        // in son process
        fprintf(fp, "from son processn");
    } else {
        // in father process
        fprintf(fp, "from father processn");
    }

    fprintf(fp, "donen");

    fclose(fp);
    return 0;
}

这份代码可以生成以下的文件

hello world
from father process
done
hello world
from son process
done

需要注意的是第 4 行和第 6 行，多了一个 hello world 和 done

那么，接下来试试在父进程中关掉文件句柄

一开始，我是这样尝试着关闭的

#include <stdio.h>
#include <unistd.h>

int main(int argc, char **argv) {
    FILE *fp;
    if ((fp=fopen("test.out", "w+")) == NULL) {
        printf("open file failedn");
        return -1;
    }
    fprintf(fp, "hello worldn");

    pid_t fpid;
    fpid = fork();
    if (fpid < 0) {
        printf("error in forkn");
        return -1;
    } else if (fpid == 0) {
        // in son process
        fprintf(fp, "from son processn");
    } else {
        // in father process
        fprintf(fp, "from father processn");
        if (fp != NULL) {
            fclose(fp);
        }
    }

    fprintf(fp, "donen");

    if (fp != NULL) {
        fclose(fp);
    }

    return 0;
}

跑起来报

*** glibc detected *** ./fork: double free or corruption (top): 0x092fe008 ***
======= Backtrace: =========
/lib/i386-linux-gnu/libc.so.6(+0x73e42)[0xb7699e42]
/lib/i386-linux-gnu/libc.so.6(fclose+0x154)[0xb7689384]
./fork[0x80485dd]
/lib/i386-linux-gnu/libc.so.6(__libc_start_main+0xf3)[0xb763f4d3]
./fork[0x8048421]
======= Memory map: ========
08048000-08049000 r-xp 00000000 08:01 1063761    /home/zrj/c/fork/fork
08049000-0804a000 r--p 00000000 08:01 1063761    /home/zrj/c/fork/fork
0804a000-0804b000 rw-p 00001000 08:01 1063761    /home/zrj/c/fork/fork
092fe000-0931f000 rw-p 00000000 00:00 0          [heap]
b75f7000-b7613000 r-xp 00000000 08:01 1049526    /lib/i386-linux-gnu/libgcc_s.so.1
b7613000-b7614000 r--p 0001b000 08:01 1049526    /lib/i386-linux-gnu/libgcc_s.so.1
b7614000-b7615000 rw-p 0001c000 08:01 1049526    /lib/i386-linux-gnu/libgcc_s.so.1
b7625000-b7626000 rw-p 00000000 00:00 0
b7626000-b77c5000 r-xp 00000000 08:01 1049505    /lib/i386-linux-gnu/libc-2.15.so
b77c5000-b77c7000 r--p 0019f000 08:01 1049505    /lib/i386-linux-gnu/libc-2.15.so
b77c7000-b77c8000 rw-p 001a1000 08:01 1049505    /lib/i386-linux-gnu/libc-2.15.so
b77c8000-b77cb000 rw-p 00000000 00:00 0
b77da000-b77dd000 rw-p 00000000 00:00 0
b77dd000-b77de000 r-xp 00000000 00:00 0          [vdso]
b77de000-b77fe000 r-xp 00000000 08:01 1049485    /lib/i386-linux-gnu/ld-2.15.so
b77fe000-b77ff000 r--p 0001f000 08:01 1049485    /lib/i386-linux-gnu/ld-2.15.so
b77ff000-b7800000 rw-p 00020000 08:01 1049485    /lib/i386-linux-gnu/ld-2.15.so
bf940000-bf961000 rw-p 00000000 00:00 0          [stack]
已放弃 (核心已转储)

既然他说 double free，那就试试只 free 一次，改成这样后可以正常运行

#include <stdio.h>
#include <unistd.h>

int main(int argc, char **argv) {
    FILE *fp;
    if ((fp=fopen("test.out", "w+")) == NULL) {
        printf("open file failedn");
        return -1;
    }
    fprintf(fp, "hello worldn");

    pid_t fpid;
    fpid = fork();
    if (fpid < 0) {
        printf("error in forkn");
        return -1;
    } else if (fpid == 0) {
        // in son process
        fprintf(fp, "from son processn");
    } else {
        // in father process
        fprintf(fp, "from father processn");
        if (fp != NULL) {
            fclose(fp);
        }
    }

    fprintf(fp, "donen");

    return 0;
}

结果是

hello world
from father process
hello world
from son process
done

从结果看，父进程关闭文件句柄，对于子进程应该是没有影响的。背后的原因，不知道是否与 copy-on-write 有关。

============================================

update：上面的第一次 fclose 之前虽然有判空，但是在 fclose 之后没有置空，典型的野指针问题，那么试试该改成这样？

#include <stdio.h>
#include <unistd.h>

int main(int argc, char **argv) {
    FILE *fp;
    if ((fp=fopen("test.out", "w+")) == NULL) {
        printf("open file failedn");
        return -1;
    }
    fprintf(fp, "hello worldn");

    pid_t fpid;
    fpid = fork();
    if (fpid < 0) {
        printf("error in forkn");
        return -1;
    } else if (fpid == 0) {
        // in son process
        fprintf(fp, "from son processn");
    } else {
        // in father process
        fprintf(fp, "from father processn");
        if (fp != NULL) {
            fclose(fp);
            fp = NULL;
        }
    }

    fprintf(fp, "donen");

    if (fp != NULL) {
        fclose(fp);
        fp = NULL;
    }

    return 0;
}

结果直接段错误

段错误 (核心已转储)

===============================================

update 最开始的那份代码中，hello world 出现了两次，这个其实是缓冲区引起的，具体的解释可以看这篇文章，http://coolshell.cn/articles/7965.html，改成这样之后

#include <stdio.h>
#include <unistd.h>

int main(int argc, char **argv) {
    FILE *fp;
    if ((fp=fopen("test.out", "w+")) == NULL) {
        printf("open file failedn");
        return -1;
    }
    fprintf(fp, "hello world, %dn", getpid());
    fflush(fp);

    pid_t fpid;
    fpid = fork();
    if (fpid < 0) {
        printf("error in forkn");
        return -1;
    } else if (fpid == 0) {
        // in son process
        fprintf(fp, "from son processn");
        fflush(fp);
    } else {
        // in father process
        fprintf(fp, "from father processn");
        fflush(fp);
    }

    fprintf(fp, "donen");
    fflush(fp);

    return 0;
}

输出变成这样

hello world, 13047
from father process
done
from son process
done

这就符合预期了

printf 一定需要 stdio.h 吗

Sun, 30 Sep 2012 09:01:32 +0800

刚刚看到一个范例代码，调用了 printf 函数，但是却没有包含 stdio.h 的头文件，这种写法第一反应就应该是不对的啊，本着动手实验的原则，试了一下

zrj@vm:~/c/test$ cat test.c
int main() {
    printf("hello worldn");
    return 0;
}
zrj@vm:~/c/test$ gcc -o test test.c
test.c: 在函数‘main’中:
test.c:2:5: 警告： 隐式声明与内建函数‘printf’不兼容 [默认启用]
zrj@vm:~/c/test$ ./test
hello world

发现确实是可以的，gcc 在编译的时候给了一个警告，但是能够正常的生成可执行文件，而且也能正常的运行出结果，找了一下，在这里，http://wiki.ubuntu.org.cn/Gcchowto，找到解释

链接外部库库是预编译的目标文件(object files)的集合，它们可被链接进程序。静态库以后缀为‘.a’的特殊的存档文件(archive file)存储。

标准系统库可在目录 /usr/lib 与 /lib 中找到。比如，在类 Unix 系统中 C 语言的数学库一般存储为文件 /usr/lib/libm.a。该库中函数的原型声明在头文件 /usr/include/math.h 中。C 标准库本身存储为 /usr/lib/libc.a，它包含 ANSI/ISO C 标准指定的函数，比如‘printf’。对每一个 C 程序来说，libc.a 都默认被链接。

============================================

2012-10-05 14:27:11 update 在这里，http://zhidao.baidu.com/question/341065125.html?seed=0，有更好的解释

由于编译器在处理函数调用代码时没有找到函数原型，只好根据函数调用代码做隐式声明. 为什么编译器在处理函数调用代码时需要有函数原型？因为必须知道参数的类型和个数以及返回值的类型才知道生成什么样的指令。为什么隐式声明靠不住呢？因为隐式声明是从函数调用代码推导而来的，而事实上函数定义的形参类型可能跟函数调用代码传的实参类型并不一致，如果函数定义带有可变参数（例如printf），那么从函数调用代码也看不出来这个函数带有可变参数，另外，从函数调用代码也看不出来返回值应该是什么类型，所以隐式声明只能规定返回值都是int型的。既然隐式声明靠不住，那编译器为什么不自己去找函数定义，而非要让我们在调用之前写函数原型呢？因为编译器往往不知道去哪里找函数定义.

Linux C 多线程初步

Tue, 04 Sep 2012 22:07:23 +0800

晚上想起来要敲一个 C 的多线程，于是搜了一下，找到这篇，http://zhuwenlong.blog.51cto.com/blog/209020/40339

#include <stdio.h>
#include <pthread.h>
#include <string.h>
#include <stdlib.h>
#include <sys/time.h>

#define MAX 10

pthread_t thread[2];
pthread_mutex_t mut;

int number=0, i;

void *thread1() {
    printf("thread1n");
    for (i=0; i<MAX; i++) {
        printf("thread1, number = %dn", number);
        pthread_mutex_lock(&mut);
        number++;
        pthread_mutex_unlock(&mut);
        sleep(2);
    }
    printf("thread1, is main processing waiting for me?n");
    pthread_exit(NULL);
}

void *thread2() {
    printf("thread2n");
    for (i=0; i<MAX; i++) {
        printf("thread2, number = %dn", number);
        pthread_mutex_lock(&mut);
        number++;
        pthread_mutex_unlock(&mut);
        sleep(3);
    }
    printf("thread2, is main processing waiting for me?n");
    pthread_exit(NULL);
}

void thread_create() {
    int temp;
    memset(&thread, 0, sizeof(thread));
    if ((temp = pthread_create(&thread[0], NULL, thread1, NULL)) != 0) {
        printf("create threadh 1 failedn");
    } else {
        printf("successfully create thread 1n");
    }

    if ((temp = pthread_create(&thread[1], NULL, thread2, NULL)) != 0) {
        printf("create threadh 2 failedn");
    } else {
        printf("successfully create thread 2n");
    }
}

void thread_wait() {
    if (thread[0] != 0) {
        pthread_join(thread[0], NULL);
        printf("thread 1 endn");
    }
    if (thread[1] != 0) {
        pthread_join(thread[1], NULL);
        printf("thread 2 endn");
    }
}

int main() {
    printf("hello worldn");
    pthread_mutex_init(&mut, NULL);
    printf("this is the main processn");
    thread_create();
    printf("main process is waiting for pthread to finishn");
    thread_wait();
    return 0;
}

需要注意的是，编译的时候需要手工链接进程库

gcc -pthread thread.c

后续的解释，直接引用了。。

引文:

线程相关操作

一 pthread_t

pthread_t在头文件/usr/include/bits/pthreadtypes.h中定义：

typedef unsigned long int pthread_t;

它是一个线程的标识符。

二 pthread_create

函数pthread_create用来创建一个线程，它的原型为：

extern int pthread_create __P ((pthread_t *__thread, __const pthread_attr_t *__attr,

void *(*__start_routine) (void *), void *__arg));

第一个参数为指向线程标识符的指针，第二个参数用来设置线程属性，第三个参数是线程运行函数的起始地址，最后一个参数是运行函数的参数。这里，我们的函数thread不需要参数，所以最后一个参数设为空指针。第二个参数我们也设为空指针，这样将生成默认属性的线程。对线程属性的设定和修改我们将在下一节阐述。当创建线程成功时，函数返回0，若不为0则说明创建线程失败，常见的错误返回代码为EAGAIN和EINVAL。前者表示系统限制创建新的线程，例如线程数目过多了；后者表示第二个参数代表的线程属性值非法。创建线程成功后，新创建的线程则运行参数三和参数四确定的函数，原来的线程则继续运行下一行代码。

三 pthread_join pthread_exit

函数pthread_join用来等待一个线程的结束。函数原型为：

extern int pthread_join __P ((pthread_t __th, void **__thread_return));

第一个参数为被等待的线程标识符，第二个参数为一个用户定义的指针，它可以用来存储被等待线程的返回值。这个函数是一个线程阻塞的函数，调用它的函数将一直等待到被等待的线程结束为止，当函数返回时，被等待线程的资源被收回。一个线程的结束有两种途径，一种是象我们上面的例子一样，函数结束了，调用它的线程也就结束了；另一种方式是通过函数pthread_exit来实现。它的函数原型为：

extern void pthread_exit __P ((void *__retval)) __attribute__ ((__noreturn__));

唯一的参数是函数的返回代码，只要pthread_join中的第二个参数thread_return不是NULL，这个值将被传递给 thread_return。最后要说明的是，一个线程不能被多个线程等待，否则第一个接收到信号的线程成功返回，其余调用pthread_join的线程则返回错误代码ESRCH。

在这一节里，我们编写了一个最简单的线程，并掌握了最常用的三个函数pthread_create，pthread_join和pthread_exit。下面，我们来了解线程的一些常用属性以及如何设置这些属性。

互斥锁相关

互斥锁用来保证一段时间内只有一个线程在执行一段代码。

一 pthread_mutex_init

函数pthread_mutex_init用来生成一个互斥锁。NULL参数表明使用默认属性。如果需要声明特定属性的互斥锁，须调用函数 pthread_mutexattr_init。函数pthread_mutexattr_setpshared和函数 pthread_mutexattr_settype用来设置互斥锁属性。前一个函数设置属性pshared，它有两个取值， PTHREAD_PROCESS_PRIVATE和PTHREAD_PROCESS_SHARED。前者用来不同进程中的线程同步，后者用于同步本进程的不同线程。在上面的例子中，我们使用的是默认属性PTHREAD_PROCESS_ PRIVATE。后者用来设置互斥锁类型，可选的类型有PTHREAD_MUTEX_NORMAL、PTHREAD_MUTEX_ERRORCHECK、 PTHREAD_MUTEX_RECURSIVE和PTHREAD _MUTEX_DEFAULT。它们分别定义了不同的上所、解锁机制，一般情况下，选用最后一个默认属性。

二 pthread_mutex_lock pthread_mutex_unlock pthread_delay_np

pthread_mutex_lock声明开始用互斥锁上锁，此后的代码直至调用pthread_mutex_unlock为止，均被上锁，即同一时间只能被一个线程调用执行。当一个线程执行到pthread_mutex_lock处时，如果该锁此时被另一个线程使用，那此线程被阻塞，即程序将等待到另一个线程释放此互斥锁。

注意：

1 需要说明的是，上面的两处sleep不光是为了演示的需要，也是为了让线程睡眠一段时间，让线程释放互斥锁，等待另一个线程使用此锁。下面的参考资料1里头说明了该问题。但是在linux下好像没有pthread_delay_np那个函数（我试了一下，提示没有定义该函数的引用），所以我用了sleep来代替，不过参考资料2中给出另一种方法，好像是通过pthread_cond_timedwait来代替，里头给出了一种实现的办法。

2 请千万要注意里头的注释comment1-5，那是我花了几个小时才找出的问题所在。

如果没有comment1和comment4,comment5,将导致在pthread_join的时候出现段错误，另外，上面的comment2和comment3是根源所在，所以千万要记得写全代码。因为上面的线程可能没有创建成功，导致下面不可能等到那个线程结束，而在用pthread_join的时候出现段错误（访问了未知的内存区）。另外，在使用memset的时候，需要包含string.h头文件哦

==================================================

刚刚需要用的时候，发现上面的代码不能跑，神奇，我当时是怎么出结果的，下面的代码可以跑

#include <stdio.h>
#include <pthread.h>
#include <string.h>
#include <stdlib.h>
#include <sys/time.h>
#include <unistd.h>

#define MAX 10

pthread_t thread[2];
pthread_mutex_t mut;

int number=0, i;

void *thread1(void *) {
    printf("thread1\n");
    for (i=0; i<MAX; i++) {
        printf("thread1, number = %d\n", number);
        pthread_mutex_lock(&mut);
        number++;
        pthread_mutex_unlock(&mut);
        sleep(2);
    }
    printf("thread1, is main processing waiting for me?\n");
    pthread_exit(NULL);
}

void *thread2(void *) {
    printf("thread2\n");
    for (i=0; i<MAX; i++) {
        printf("thread2, number = %d\n", number);
        pthread_mutex_lock(&mut);
        number++;
        pthread_mutex_unlock(&mut);
        sleep(3);
    }
    printf("thread2, is main processing waiting for me?\n");
    pthread_exit(NULL);
}

void thread_create() {
    int temp;
    memset(&thread, 0, sizeof(thread));
    if ((temp = pthread_create(&thread[0], NULL, thread1, NULL)) != 0) {
        printf("create threadh 1 failed\n");
    } else {
        printf("successfully create thread 1\n");
    }

    if ((temp = pthread_create(&thread[1], NULL, thread2, NULL)) != 0) {
        printf("create threadh 2 failed\n");
    } else {
        printf("successfully create thread 2\n");
    }
}

void thread_wait() {
    if (thread[0] != 0) {
        pthread_join(thread[0], NULL);
        printf("thread 1 end\n");
    }
    if (thread[1] != 0) {
        pthread_join(thread[1], NULL);
        printf("thread 2 end\n");
    }
}

int main() {
    printf("hello world\n");
    pthread_mutex_init(&mut, NULL);
    printf("this is the main process\n");
    thread_create();
    printf("main process is waiting for pthread to finish\n");
    thread_wait();
    return 0;
}

Apache ab 压力测试

Sat, 18 Aug 2012 17:34:51 +0800

apache 的 ab 真的是非常容易用，直接的说，就是下面这条命令就够了

C:Program FilesApache Software FoundationApache2.2bin>ab -n 100 -c 10 http://localhost/index2.html

这里我 index 的 html 文件就是 apache 的 it works 文件，在我的机子上，测试结果的吞吐率是 2000 多，应该算是比较低的一个数字了，对于这么简单的文本来说，正式的服务器，应该有 5000 左右，不过我的平台是 Windows 嘛。。

C:Program FilesApache Software FoundationApache2.2bin>ab -n 100 -c 10 http:/
/localhost/index2.html
This is ApacheBench, Version 2.3 <$Revision: 655654 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking localhost (be patient).....done

Server Software:        Apache/2.2.22
Server Hostname:        localhost
Server Port:            80

Document Path:          /index2.html
Document Length:        44 bytes

Concurrency Level:      10
Time taken for tests:   0.049 seconds
Complete requests:      100
Failed requests:        0
Write errors:           0
Total transferred:      32000 bytes
HTML transferred:       4400 bytes
Requests per second:    2040.69 [#/sec] (mean)
Time per request:       4.900 [ms] (mean)
Time per request:       0.490 [ms] (mean, across all concurrent requests)
Transfer rate:          637.72 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    0   0.4      0       1
Processing:     2    4   2.5      3      20
Waiting:        1    4   2.5      3      19
Total:          2    5   2.5      4      20

Percentage of the requests served within a certain time (ms)
  50%      4
  66%      4
  75%      5
  80%      6
  90%      8
  95%      8
  98%      9
  99%     20
 100%     20 (longest request)

C:Program FilesApache Software FoundationApache2.2bin>

对于一个打印 phpinfo 的 php 页面来说，成绩就更加惨不忍睹了，只有 90 多

C:Program FilesApache Software FoundationApache2.2bin>ab -n 100 -c 10 http:/
/localhost/index2.php
This is ApacheBench, Version 2.3 <$Revision: 655654 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking localhost (be patient).....done

Server Software:        Apache/2.2.22
Server Hostname:        localhost
Server Port:            80

Document Path:          /index2.php
Document Length:        67839 bytes

Concurrency Level:      10
Time taken for tests:   1.015 seconds
Complete requests:      100
Failed requests:        45
   (Connect: 0, Receive: 0, Length: 45, Exceptions: 0)
Write errors:           0
Total transferred:      6801290 bytes
HTML transferred:       6783990 bytes
Requests per second:    98.57 [#/sec] (mean)
Time per request:       101.454 [ms] (mean)
Time per request:       10.145 [ms] (mean, across all concurrent requests)
Transfer rate:          6546.67 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    1   1.2      0       8
Processing:     3   50 153.5     15    1012
Waiting:        3   49 153.6     13    1011
Total:          3   51 153.4     15    1012

Percentage of the requests served within a certain time (ms)
  50%     15
  66%     18
  75%     21
  80%     25
  90%     88
  95%    348
  98%   1012
  99%   1012
 100%   1012 (longest request)

C:Program FilesApache Software FoundationApache2.2bin>

那么，如果我们把 it work 用 php echo 出来呢，就是说，送进 php 解释器里面转一圈，来看看，依然只有 90 多

C:Program FilesApache Software FoundationApache2.2bin>ab -n 100 -c 10 http:/
/localhost/index3.php
This is ApacheBench, Version 2.3 <$Revision: 655654 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking localhost (be patient).....done

Server Software:        Apache/2.2.22
Server Hostname:        localhost
Server Port:            80

Document Path:          /index3.php
Document Length:        8 bytes

Concurrency Level:      10
Time taken for tests:   1.049 seconds
Complete requests:      100
Failed requests:        0
Write errors:           0
Total transferred:      18100 bytes
HTML transferred:       800 bytes
Requests per second:    95.32 [#/sec] (mean)
Time per request:       104.906 [ms] (mean)
Time per request:       10.491 [ms] (mean, across all concurrent requests)
Transfer rate:          16.85 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    0   0.5      0       1
Processing:     2   18  99.6      8    1004
Waiting:        2   18  99.7      8    1004
Total:          2   19  99.6      9    1004

Percentage of the requests served within a certain time (ms)
  50%      9
  66%      9
  75%     10
  80%     11
  90%     13
  95%     14
  98%     31
  99%   1004
 100%   1004 (longest request)

C:Program FilesApache Software FoundationApache2.2bin>

再来看看 php 访问数据库的时候的成绩，访问数据我们就用一条 select 语句，php 代码如下

<?php
mysql_connect("localhost", "root", "root") or die(mysql_error());
mysql_select_db("mailbox");
mysql_query("set names gbk");
$result = mysql_query("select * from mail where id = 118593");
while($row = mysql_fetch_array($result)) {
	var_dump($row);
}

算是非常中规中矩的读取了，结果如下，吞吐率只有 80 多

C:Program FilesApache Software FoundationApache2.2bin>ab -n 100 -c 10 http:/
/localhost/index4.php
This is ApacheBench, Version 2.3 <$Revision: 655654 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking localhost (be patient).....done

Server Software:        Apache/2.2.22
Server Hostname:        localhost
Server Port:            80

Document Path:          /index4.php
Document Length:        6108 bytes

Concurrency Level:      10
Time taken for tests:   1.157 seconds
Complete requests:      100
Failed requests:        0
Write errors:           0
Total transferred:      628100 bytes
HTML transferred:       610800 bytes
Requests per second:    86.43 [#/sec] (mean)
Time per request:       115.707 [ms] (mean)
Time per request:       11.571 [ms] (mean, across all concurrent requests)
Transfer rate:          530.12 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    0   0.4      0       1
Processing:     6  100 301.8     10    1154
Waiting:        6   99 301.8     10    1154
Total:          6  100 301.7     11    1154

Percentage of the requests served within a certain time (ms)
  50%     11
  66%     16
  75%     16
  80%     16
  90%     22
  95%   1145
  98%   1153
  99%   1154
 100%   1154 (longest request)

C:Program FilesApache Software FoundationApache2.2bin>

那么，如果我们用 apache 把 php 的结果缓存起来呢？这个想法非常赞，可惜我这里配的是 apache fastcgi php 的模式，简单 google 了一下并没有发现相关的文章，倒是 nginx fastcgi php 的缓存有很多的讨论，也是，人家本来就是做反向代理的嘛，不过，根据高性能 web 那本书的记载，应该是可以有 5 倍左右的提升的，还是很垂涎的，呵呵。强烈推荐这本高性能 web 的书，http://book.douban.com/subject/3924175/

最后插播一下，对于一台 debian 的虚拟机，成绩其实没有想象中的飞跃，这台虚拟机开的内存是 256，一样请求一个静态文件，结果如下，顺便一提，虚拟机里面跑着的是 nginx，不是 apache

C:Program FilesApache Software FoundationApache2.2bin>ab -n 1000 -c 10 http:
//192.168.128.133:8080/index.html
This is ApacheBench, Version 2.3 <$Revision: 655654 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking 192.168.128.133 (be patient)
Completed 100 requests
Completed 200 requests
Completed 300 requests
Completed 400 requests
Completed 500 requests
Completed 600 requests
Completed 700 requests
Completed 800 requests
Completed 900 requests
Completed 1000 requests
Finished 1000 requests

Server Software:        Apache/2.2.20
Server Hostname:        192.168.128.133
Server Port:            8080

Document Path:          /index.html
Document Length:        12 bytes

Concurrency Level:      10
Time taken for tests:   0.632 seconds
Complete requests:      1000
Failed requests:        0
Write errors:           0
Total transferred:      297000 bytes
HTML transferred:       12000 bytes
Requests per second:    1582.19 [#/sec] (mean)
Time per request:       6.320 [ms] (mean)
Time per request:       0.632 [ms] (mean, across all concurrent requests)
Transfer rate:          458.90 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    1   0.5      1       2
Processing:     1    6   1.1      6      19
Waiting:        0    4   1.5      4      17
Total:          2    6   1.1      6      20

Percentage of the requests served within a certain time (ms)
  50%      6
  66%      6
  75%      6
  80%      7
  90%      7
  95%      8
  98%      9
  99%     10
 100%     20 (longest request)

C:Program FilesApache Software FoundationApache2.2bin>

try git 的一些学习笔记

Wed, 08 Aug 2012 17:34:50 +0800

昨天由江阁介绍，发现了一个在线试用 git 的好地方，http://try.github.com/levels/1/challenges/1，今天重新做一遍，同时当作笔记记录下来：

首先，使用 git init 命令来初始化 git 仓库，这个命令的主要作用是建立 .git 隐藏文件夹，里面存放着 git 本身跟踪用的一些文件，具体细节没有探究。
我们随时可以使用 git status 来查看当前的仓库状态。
当我们新增了一个文件之后，在 git status 中会得到

# On branch master
#
# Initial commit
#
# Untracked files:
#   (use "git add <file>..." to include in what will be committed)
#
#	octocat.txt
nothing added to commit but untracked files present (use "git add" to track)

表示文件没有处于被跟踪的状态，也就是无法进行版本控制 4. 那么这个时候我们应该是用 git add octocat.txt 来把文件纳入版本库，之后可以得到

# On branch master
#
# Initial commit
#
# Changes to be committed:
#   (use "git rm --cached <file>..." to unstage)
#
#	new file:   octocat.txt
#

然后 git commit -m “Add cute octocat story” 来提交文件到本地版本库
使用 git add ‘*.txt’ 来添加多个文件
然后再次提交，git commit -m ‘Add all the octocat txt files’
使用 git log 来查看日志记录

commit 1ed21fdf91684c6f35300acde109205f4f398075
Author: Try Git <try_git@github.com>
Date:   Wed Aug 8 09:01:12 2012 +0000

    Add all the octocat txt files

commit d8e36726c76410640149058c4644d6021a3f0a40
Author: Try Git <try_git@github.com>
Date:   Wed Aug 8 09:01:12 2012 +0000

    Added cute octocat story

使用 git remote add origin git@github.com:ZRJ/try_git.git 来添加远程版本库
使用 git push -u origin master 把本地的库推送到服务器上，这里的参数需要了解一下

The name of our remote is origin and the default local branch name is master. The -u tells Git to remember the parameters, so that next time we can simply run git push and Git will know what to do. Go ahead and push it!

然后，假设有人修改了服务器上的版本，我们需要更新本地的库，git pull origin master
可以使用 git diff HEAD 来查看被修改的部分

diff --git a/octocat.txt b/octocat.txt
index 7d8d808..e725ef6 100644
--- a/octocat.txt
+++ b/octocat.txt
@@ -1 +1 @@
-A Tale of Two Octocats
+A Tale of Two Octocats and an Octodog

然后再往本地库里面添加一个我们的文件，git add octofamily/octodog.txt
使用 git diff –staged 来查看未提交的修改

diff --git a/octofamily/octodog.txt b/octofamily/octodog.txt
new file mode 100644
index 0000000..cfbc74a
--- /dev/null
+++ b/octofamily/octodog.txt
@@ -0,0 +1 @@
+woof

使用 git reset octofamily/octodog.txt 来移除文件，但是文件依然在硬盘上，在执行这个命令之前，git status 是这样的

# On branch master
# Changes to be committed:
#   (use "git reset HEAD <file>..." to unstage)
#
#	new file:   octofamily/octodog.txt
#
# Changes not staged for commit:
#   (use "git add <file>..." to update what will be committed)
#   (use "git checkout -- <file>..." to discard changes in working directory)
#
#	modified:   octocat.txt
#

执行之后的 git status 是

# On branch master
# Changes not staged for commit:
#   (use "git add <file>..." to update what will be committed)
#   (use "git checkout -- <file>..." to discard changes in working directory)
#
#	modified:   octocat.txt
#
# Untracked files:
#   (use "git add <file>..." to include in what will be committed)
#
#	octofamily/octodog.txt

官方文档也有说

git reset did a great job of unstaging octodog.txt, but you’ll notice that he’s still there. He’s just not staged anymore. It would be great if we could go back to how things were before octodog came around and ruined the party.

使用 git checkout – octocat.txt 来恢复文件到最后一次提交的状态
使用 git branch clean_up 来建立一个新的分支，紧接着使用 git checkout clean_up 来切换到新的分支上
在新的分支中删除所有文件，git rm ‘*.txt’ 这里使用 git 的 rm 来删除

git rm command which will not only remove the actual files from disk, but will also stage the removal of the files for us.

删除之后的 git status

# On branch clean_up
# Changes to be committed:
#   (use "git reset HEAD <file>..." to unstage)
#
#	deleted:    blue_octocat.txt
#	deleted:    octocat.txt
#	deleted:    octofamily/baby_octocat.txt
#	deleted:    octofamily/momma_octocat.txt
#	deleted:    red_octocat.txt
#
# Untracked files:
#   (use "git add <file>..." to include in what will be committed)
#
#	octofamily/

然后提交修改 git commit -m “Remove all the cats”
切换到主分支，git checkout master，注意到，切换到主分支后，那些 txt 文件又出现了
把清理的分支合并到当前的分支上，git merge clean_up

Updating f625815..ec52ea9
Fast-forward
 blue_octocat.txt             | 1 -
 octocat.txt                  | 1 -
 octofamily/baby_octocat.txt  | 1 -
 octofamily/momma_octocat.txt | 1 -
 red_octocat.txt              | 1 -
 5 files changed, 5 deletions(-)
 delete mode 100644 blue_octocat.txt
 delete mode 100644 octocat.txt
 delete mode 100644 octofamily/baby_octocat.txt
 delete mode 100644 octofamily/momma_octocat.txt
 delete mode 100644 red_octocat.txt

删除清理的分支，git branch -d clean_up
推送到远程服务器上，git push

apt update 时软件包说明的数量了超出本程序的处理能力

Mon, 06 Aug 2012 11:08:53 +0800

一个上午基本上都在折腾这个了，坑爹啊

继上次 Linux 里面配多个 Python 出现 easy_install 出错的问题之后，问了江阁，他给了两个方法，一个用系统的包管理升级到 python 2.7 ，另外一个就是自己一切手动来。

上午试了一下自己配一点，发现没到那个水平，配的时候总是会出现各种错，而且错的比较灵异，想来是对 Linux 的细节还不够把握，于是试着升级的方法

教程看的是这里的教程，http://www.coder4.com/archives/1551，看起来步骤简单明了，但是在

sudo apt-get update

的时候出现了问题，首先遇到：

Dynamic MMap ran out of room. Please increase the size of APT::Cache-Limit

于是跟着网上的方法，http://languor.us/e-dynamic-mmap-ran-out-room-please-increase-size-apt-cache-limit

To fix this, navigate to /etc/apt/apt.conf.d and edit the file related to debconf which in my case was 70debconf. Add the following line to the bottom of this file and save it: APT::Cache-Limit “200000000”;

然后往后走，报错：

命中 http://security.debian.org stable/updates/main Packages
下载 23.5kB，耗时 25s (912B/s)
正在读取软件包列表... 有错误!
E: 糟了，软件包说明的数量了超出本程序的处理能力。
E: Problem with MergeList /var/lib/dpkg/status
E: 无法解析或打开软件包的列表或是状态文件。

于是 google 一阵搜，看到网上很多人的方法是，http://forum.ubuntu.org.cn/viewtopic.php?f=50&t=151642

* 在终端中运行 gksu gedit /etc/apt/sources.list * 编辑sources.list文件，屏蔽rchive.ubuntu.com更新服务器（欧洲，此为官方源，电信、网通用户使用）将其下的源前加“#”，保存、退出 * 重新启动更新源管理服务器，搜索升级包。

但是我根本就没有添加过这个源，又看到http://ihaveapc.com/2011/05/how-to-fix-problem-with-mergelist-varlibaptlists-error-in-ubuntu-11-04/

From the Terminal type the following commands :

sudo rm /var/lib/apt/lists/* -vf and

sudo apt-get update

但是还是没用，注意到报错前，去 163 的镜像读取过文件，但是我的 /etc/apt/source.list 里面是没有的，纠结了许久，发现在 /etc/apt/ 下有一个 source.list.d 文件夹，进去有一个 apt-spy.list 文件，里面写着 163 的源，想起来之前装过一个类似的软件，http://blog.netroby.com/article-4199.html，是用来寻找速度快的源的，坑爹啊，这里还影响 apt-get update 的行为，把这里注释掉，终于可以顺利的 update 了。

Linux 下多个 Python 版本造成 easy_install 出错

Sat, 04 Aug 2012 16:50:41 +0800

debian 默认有 python 2.5 ，我下了 2.73 的源码包自己编译安装了，也改了系统的默认调用

sudo rm /usr/bin/python
sudo ln -s /usr/lib/python2.73/python2.7 /usr/bin/python

这样确实可以默认启用 2.73 的 python ，但是后来使用

sudo apt-get install python-setuptools
sudo easy_install pip

的时候就报错，报 No module named pkg_resources

看起来像是找不到模块，猜想是 setuptools 安装到了 2.5 的下面去了，于是把软连接改回来，就可以正常使用 easy_install

问题是怎么让系统承认 2.73 并把 setuptools 装到新的里面去啊