yaron's space

gdb调试程序之监控内存【七】

admin — Sun, 12 Feb 2012 08:56:02 +0000

gdb提供awtach rwatch watch来监控调试中变量或者内存的变化

awatch 命令

awtach [expr]

当debugger read或者write该expr时，debugger 停止

rwatch 命令

rwatch [expr]

当debugger read该expr时，debugger停止

watch命令

watch [expr]

当debugger write该expr时，debugger停止

说明：expr可以是变量或者是内存地址

2011年的最后一天

admin — Sat, 31 Dec 2011 09:41:45 +0000

马上就2012了，实验室的人都跑光了，一会我也闪人，分享个华为的年终晚会视频，比较有意思

晚上写下总结

vim使用技巧小结【继续更新】

admin — Thu, 22 Dec 2011 08:20:47 +0000

笔者在本博客上之前记录了vim相关方面的用法，现在总结下，记录的文章如下：

1. vim中recording模式详解

2. Vim纵向编辑模式的用法

3. vim templates模板用法介绍

4. vim中两个实用插件doxygen和projects的安装与使用

5. VIM查找替换归纳总结

6. vim编辑多个文件的方法

7. vim插件之TagList安装与使用方法

今天在云云网上看到有人发帖收集常用的vim技巧，现在也记录下

1.在以普通用户打开的VIM当中保存一个ROOT用户文件

: w !sudo tee %

2. 把所有的行都翻转

把所有行的顺序反转， 比如：
1
2
3
变为>
3
2>
1
方法 :g/^/m0
解释：

: 开始命令行
g 表示对匹配后面正则的行采取动作
/ 开始正则
^ 匹配行首， 这里就是想匹配所有行
/ 结束正则， 后面跟的是动作
m 意思是移动
0 是移动的目的行， 第0行， 也就是开头


这个命令就是把每一行都移到开头， 结果就把所有行反转了
g开头的命令还有一些常用的：

删除包含foo的行   :g/foo/d
删除不包含foo的行 :g!/foo/d

3. ctrl+a 将光标下的数字加1
ctrl+x 将光标下数字减1

比较全的技巧文档：http://www.rayninfo.co.uk/vimtips.html

积攒人品

admin — Fri, 11 Nov 2011 06:53:07 +0000

关于const与volatile笔试题目的分析

admin — Mon, 17 Oct 2011 06:26:24 +0000

昨天笔试遇到了关于c++中关于const与const_cast的题目，大概如下：

CPP CODE

int main(int argc, char* argv[])
{
     const int a = 10;
     int * p = const_cast<int *>(&a);
     *p = 1;
     printf("%d %d\n", a, *p);
     return 0;
}

求上述程序的输出结果，正确答案是：10 1

分析如下：

首先可以确定是p和&a的地址是指向同一片内存区域的，理论上来说最后的输出结果应该是1 1
但是为什么会输出a的值为10呢？猜测应该是const关键字的问题，可能编译器看到a为const型变量，所以在编译期就将所有的a直接替换为10了，这个是编译器做的一个优化，
下面简单的验证下：
直接使用下面的命令来看下编译后的汇编代码，关键部分的汇编如下：

ASM CODE

        movl    %edi, -20(%rbp)
        movq    %rsi, -32(%rbp)
        movl    $10, -12(%rbp)
        leaq    -12(%rbp), %rax
        movq    %rax, -8(%rbp)
        movq    -8(%rbp), %rax
        movl    $1, (%rax)
        movq    -8(%rbp), %rax
        movl    (%rax), %edx
        movl    $10, %esi
        movl    $.LC0, %edi
        movl    $0, %eax
        call    printf
        movl    $0, %eax
        leave
        ret

显然%rax中存放的指针p的值，(%rax)代表间接寻址
在调用printf函数之前，将10放入%esi, (%rax)放入到%edx中，显然验证了上述的猜想

关于volatile关键字

如何避免编译器做这方面的优化呢？
一个常用的方法是将变量a加上关键字volatile，代表是”易变，每次都需要从内存中读取，这样上述程序的运行结果就是1 1了
当然修改常量变量的值不是好的编程习惯，尽量还是少用上述用法

linux关于sort命令的高级用法（按多个列值进行排列）

admin — Sat, 08 Oct 2011 11:32:00 +0000

如果单纯地使用sort按行进行排序比较简单，

但是使用sort按多个列值排列，同时使用tab作为分隔符，而且对于某些列需要进行逆序排列，这样sort命令写起来就比较麻烦了

比如下面的文件内容，使用[TAB]进行分割:

Group-ID   Category-ID   Text        Frequency
----------------------------------------------
200        1000          oranges     10
200        900           bananas     5
200        1000          pears       8
200        1000          lemons      10
200        900           figs        4
190        700           grapes      17

下面使用这些列进行排序（列4在列3之前进行排序，而且列4是逆序排列）

    * Group ID (integer)
    * Category ID (integer)
    * Frequency “sorted in reverse order” (integer)
    * Text (alpha-numeric)

排序后的结果应该为：

Group-ID   Category-ID   Text        Frequency
----------------------------------------------
190        700           grapes      17
200        900           bananas     5
200        900           figs        4
200        1000          lemons      10
200        1000          oranges     10
200        1000          pears       8

可以直接使用sort命令来解决这个问题：

BASH CODE

sort -t $'\t' -k 1n,1 -k 2n,2 -k4rn,4 -k3,3 <my-file>

解释如下：

-t $'\t'：指定TAB为分隔符
-k 1, 1: 按照第一列的值进行排序，如果只有一个1的话，相当于告诉sort从第一列开始直接到行尾排列
n:代表是数字顺序，默认情况下市字典序，如10<2
r: reverse 逆序排列，默认情况下市正序排列

所以最后的命令：sort -t $'\t' -k 1n,1 -k 2n,2 -k4rn,4 -k3,3 my-file

参考资料：

register、volatile、restrict 三关键字的用法[转载]

admin — Thu, 06 Oct 2011 08:25:00 +0000

原文地址：register、volatile、restrict 三关键字的用法 – RaymondAmos的技术专栏 – CSDN博客.

register

使用修饰符register声明的变量属于寄存器存储类型。该类型与自动存储类型相似，具有自动存储时期、代码块作用域和内连接。声明为register 仅仅是一个请求，因此该变量仍然可能是普通的自动变量。无论哪种情况，用register修饰的变量都无法获取地址。如果没有被初始化，它的值是未定的。

volatile
volatile告诉编译器该被变量除了可被程序修改外，还可能被其他代理、线程修改。因此，当使用volatile 声明的变量的值的时候，系统总是重新从它所在的内存读取数据，而不使用寄存器中的缓存的值。比如，

CPP CODE

val1=x;
val2=x;

如果没有声明volatile，系统在给val2赋值的时候可能直接从寄存器读取x，而不是从内存的初始位置读取。那么在两次赋值之间，x完全有可能被被某些编译器未知的因素更改（比如：操作系统、硬件或者其它线程等）。如果声明为volatile，编译器将不使用缓存，而是每次都从内存重新读取x。
restrict

restrict是c99引入的，它只可以用于限定指针，并表明指针是访问一个数据对象的唯一且初始的方式，考虑下面的例子：

CPP CODE

int ar[10];
int * restrict restar=(int *)malloc(10*sizeof(int));
int *par=ar;

这里说明restar是访问由malloc()分配的内存的唯一且初始的方式。par就不是了。那么：

CPP CODE

for(n=0;n<10;n++)
{
    par[n]+=5;
    restar[n]+=5;
    ar[n]*=2;
    par[n]+=3;
    restar[n]+=3;
}

因为restar是访问分配的内存的唯一且初始的方式，那么编译器可以将上述对restar的操作进行优化：restar[n]+=8;。而par并不是访问数组ar的唯一方式，因此并不能进行下面的优化：par[n]+=8;。因为在par[n]+=3前，ar[n]*=2进行了改变。使用了关键字 restric，编译器就可以放心地进行优化了。这个关键字据说来源于古老的FORTRAN。

总结

两个关键字：volatile和restrict，两者都是为了方便编译器的优化。

今天EMC笔试题目

admin — Sun, 25 Sep 2011 11:41:21 +0000

两道的题目：

1. dup(int fd)和dup2(int fd1, int fd2)函数的区别：详细请见http://blog.donews.com/mutecat/archive/2007/09/20/1212178.aspx

2. 有关一致性哈希的算法设计

其他的是多项选择题目，涉及的范围比较广，linux和语言层次的题目偏多一些吧

包括堆栈缓冲区溢出以及linux内核中container_of宏的实现，以及spinlock和虚拟内存的相关知识

关于container_of这个请参考我的前一篇blog: http://yaronspace.cn/blog/index.php/archives/1026

debian系统sshd连接慢的解决办法

admin — Fri, 26 Aug 2011 02:42:21 +0000

最近客户端连debian下sshd很慢，每次都需要等待半分钟左右，今天终于无法忍受了，上网找了下资料，把这个问题解决了

原因：

主要是debian在默认情况下开启了dns的反向解析，这个比较耗时

解决方法：

1. 编辑/etc/nsswitch.conf 找到hosts行，替换为

hosts: files dns [NOTFOUND=return]

2. 查看/etc/resolv.conf文件，查看dns地址是否设置正确，如果没有用，直接注掉即可

3. 重启sshd ：先kill掉，然后/usr/sbin/sshd 启功即可

linux下多线程编程的几篇不错的博文

admin — Tue, 23 Aug 2011 14:15:53 +0000

选自陈硕的blog : http://blog.csdn.net/solstice

查看 CPU, Memory, I/O and NetFlow[转载]

admin — Wed, 10 Aug 2011 01:23:03 +0000

原文地址：http://blogread.cn/it/article.php?id=3908&f=sa

iostat 查看磁盘 I/O

[root@localhost ~]# iostat -d -x 2
                             extended device statistics
device mgr/s mgw/s    r/s    w/s    kr/s    kw/s   size queue   wait svc_t  %b
hda        0     0    0.0    0.9     0.1     5.4    6.3   0.0    4.7   0.9   0
                             extended device statistics
device mgr/s mgw/s    r/s    w/s    kr/s    kw/s   size queue   wait svc_t  %b
hda        0     3    0.0    2.0     0.0    20.0   10.0   0.0    0.8   0.5   0
 ......

命令释意: 查看磁盘 I/0 情况，且每两秒刷新一次

[root@localhost ~]# vmstat 5
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    284  68700 165876 416748    0    0     0     5    1    1  0  0 100  0  0
 ......

命令释意: 查看CPU使用情况的命令, 每 5 秒刷新一次，最右侧列为 CPU 的占用率的数据

top 查看进程占有率

[root@localhost ~]# top

然后在 top 的命令内部命令栏输入shift+p or P

top - 13:38:52 up 102 days,  4:17,  1 user,  load average: 0.00, 0.00, 0.00
Tasks:  81 total,   2 running,  79 sleeping,   0 stopped,   0 zombie
Cpu(s):  0.0%us,  0.0%sy,  0.0%ni,100.0%id,  0.0%wa,  0.0%hi,  0.0%si,  0.0%st
Mem:   1035292k total,   966592k used,    68700k free,   165876k buffers
Swap:  2096472k total,      284k used,  2096188k free,   416760k cached

  PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND
 4875 root      15   0  2192 1000  800 R  0.3  0.1   0:00.15 top
    1 root      15   0  2060  620  532 S  0.0  0.1   0:01.65 init
    2 root      RT  -5     0    0    0 S  0.0  0.0   0:00.00 migration/0
.......

命令释意: 查看进程处理器占用率情况，并对其进行排序

free 查看内存使用情况

[root@localhost ~]# free
             total       used       free     shared    buffers     cached
Mem:       1035292     966592      68700          0     165876     416768
-/+ buffers/cache:     383948     651344
Swap:      2096472        284    2096188

命令释意: 查看内存使用情况

top 查看进程内存使用

[root@localhost ~]# top

然后在 top 的命令内部命令栏输入shift+m or M

top - 13:48:52 up 102 days,  4:27,  1 user,  load average: 0.00, 0.01, 0.00
Tasks:  81 total,   2 running,  79 sleeping,   0 stopped,   0 zombie
Cpu(s):  0.0%us,  0.3%sy,  0.0%ni, 99.7%id,  0.0%wa,  0.0%hi,  0.0%si,  0.0%st
Mem:   1035292k total,   966592k used,    68700k free,   165876k buffers
Swap:  2096472k total,      284k used,  2096188k free,   416784k cached

  PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND
 4128 root      34  19  280m 266m 2112 S  0.0 26.4   1:48.40 yum-updatesd
 8314 www       18   0  171m  34m  34m S  0.0  3.4   0:06.03 memcacheq
 8280 www       15   0 88084  34m  588 S  0.0  3.4   0:01.23 memcached
10907 mysql     15   0  122m  16m 3892 S  0.0  1.7   0:25.29 mysqld
......

命令释意: 查看进程内存占用率情况，并对其进行排序

获得针对某个 Interface 的网络流量

[root@localhost ~]# date;ifconfig eth0
Sun Mar 13 13:51:29 CST 2011
eth0      Link encap:Ethernet  HWaddr 00:50:56:A4:0D:89
          inet addr:172.10.7.215  Bcast:172.10.7.255  Mask:255.255.248.0
          inet6 addr: fe80::250:56ff:fea4:d89/64 Scope:Link
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          RX packets:72113071 errors:12213 dropped:30790 overruns:0 frame:0
          TX packets:1062902 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1000
          RX bytes:3311165612 (3.0 GiB)  TX bytes:101244262 (96.5 MiB)
          Interrupt:59 Base address:0x2000

[root@localhost ~]# date;ifconfig eth0
Sun Mar 13 13:53:13 CST 2011
eth0      Link encap:Ethernet  HWaddr 00:50:56:A4:0D:89
          inet addr:172.10.7.215  Bcast:172.10.7.255  Mask:255.255.248.0
          inet6 addr: fe80::250:56ff:fea4:d89/64 Scope:Link
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          RX packets:72113528 errors:12213 dropped:30790 overruns:0 frame:0
          TX packets:1062968 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1000
          RX bytes:3311204659 (3.0 GiB)  TX bytes:101285190 (96.5 MiB)
          Interrupt:59 Base address:0x2000

命令释意: 通过比较两个时间网络接口的 RX 和 TX 数据来获得针对某个 Interface 的网络流量

[编程之美]随机数范围扩展方法总结

admin — Wed, 03 Aug 2011 02:50:21 +0000

问题描述

已知random3()这个随机数产生器生成[1, 3]范围的随机数，请用random3()构造random5()函数，生成[1, 5]的随机数？

问题分析

如何从[1-3]范围的数构造更大范围的数呢？同时满足这个更大范围的数出现概率是相同的，可以想到的运算包括两种：加法和乘法

考虑下面的表达式：

3 * (random3() – 1) + random3();

可以计算得到上述表达式的范围是[1, 9] 而且数的出现概率是相同的，即1/9

下面考虑如何从[1, 9]范围的数生成[1, 5]的数呢？

可以想到的方法就是 rejection sampling 方法，即生成[1, 9]的随机数，如果数的范围不在[1, 5]内，则重新取样

解决方法

CPP CODE

int random5()
{
    int val = 0;
    do {
        val = 3 * (random3() - 1) + random3();
    } while (val > 5);
    return val;
}

归纳总结

将这个问题进一步抽象，已知random_m()随机数生成器的范围是[1, m] 求random_n()生成[1, n]范围的函数，m < n && n <= m *m
一般解法：

CPP CODE

int random_n()
{
    int val = 0 ;
    int t; // t为n最大倍数，且满足 t <= m * m     
    do {         
        val = m * (random_m() - 1) + random_m();     
    } while (val > t);
    return val;
}

参考资料：

http://stackoverflow.com/questions/137783/expand-a-random-range-from-1-5-to-1-7

MySQL索引背后的数据结构及算法原理【好文】

admin — Mon, 18 Jul 2011 12:59:05 +0000

这篇文章从mysql索引的内部结构B+树来分析如何来提高索引的性能，以及索引如何进行存储等方面，

140个Google的面试题【转载】

admin — Sat, 16 Jul 2011 09:39:52 +0000

原文地址：http://coolshell.cn/articles/3345.html

来源：http://blog.seattleinterviewcoach.com/2009/02/140-google-interview-questions.html（墙）

某猎头收集了140多个Google的面试题，都张到他的Blog中了，主要是下面这些职位的，因为被墙，且无任何敏感信息，所以，我原文搬过来了。

Product Marketing Manager
Product Manager
Software Engineer
Software Engineer in Test
Quantitative Compensation Analyst
Engineering Manager
AdWords Associate

这篇Blog例举了Google用来面试下面这几个职位的面试题。很多不是很容易回答，不过都比较经典与变态，是 Google，Microsoft，Amazon之类的公司的风格。对于本文，我没有翻译，因为我相信，英文问题是最好的。不过对于有些问题，我做了一些注释，不一定对，但希望对你有帮助启发。对于一些问题，如果你百思不得其解，可以Google一下，StackOverflow或是Wikipedia上可能会给你非常全面的答案。

Product Marketing Manager

Why do you want to join Google?
What do you know about Google’s product and technology?
If you are Product Manager for Google’s Adwords, how do you plan to market this?
What would you say during an AdWords or AdSense product seminar?
Who are Google’s competitors, and how does Google compete with them?
Have you ever used Google’s products? Gmail?
What’s a creative way of marketing Google’s brand name and product?
If you are the product marketing manager for Google’s Gmail product, how do you plan to market it so as to achieve 100 million customers in 6 months?
How much money you think Google makes daily from Gmail ads?
Name a piece of technology you’ve read about recently. Now tell me your own creative execution for an ad for that product.
Say an advertiser makes $0.10 every time someone clicks on their ad. Only 20% of people who visit the site click on their ad. How many people need to visit the site for the advertiser to make $20?
Estimate the number of students who are college seniors, attend four-year schools, and graduate with a job in the United States every year.

Product Manager

How would you boost the GMail subscription base?
What is the most efficient way to sort a million integers? （陈皓：merge sort）
How would you re-position Google’s offerings to counteract competitive threats from Microsoft?
How many golf balls can fit in a school bus? （陈皓：这种题一般来说是考你的解题思路的，注意，你不能单纯地把高尔夫球当成一个小立方体，其是一个圆球，堆起来的时候应该是错开的——也就是三个相邻的球的圆心是个等边三角形）
You are shrunk to the height of a nickel and your mass is proportionally reduced so as to maintain your original density. You are then thrown into an empty glass blender. The blades will start moving in 60 seconds. What do you do?
How much should you charge to wash all the windows in Seattle?
How would you find out if a machine’s stack grows up or down in memory?
Explain a database in three sentences to your eight-year-old nephew. （陈皓：用三句话向8岁的侄子解释什么是数据库，考你的表达能力了）
How many times a day does a clock’s hands overlap?（陈皓：经典的时钟问题）
You have to get from point A to point B. You don’t know if you can get there. What would you do?
Imagine you have a closet full of shirts. It’s very hard to find a shirt. So what can you do to organize your shirts for easy retrieval? （陈皓：很不错的一道题，不要以为分类查询很容易，想想图书馆图书的分类查询问题吧。另外，你处想想如何在你在你的衣柜里实现一个相当于Hash表或是一个Tree之类的数据结构）
Every man in a village of 100 married couples has cheated on his wife. Every wife in the village instantly knows when a man other than her husband has cheated, but does not know when her own husband has. The village has a law that does not allow for adultery. Any wife who can prove that her husband is unfaithful must kill him that very day. The women of the village would never disobey this law. One day, the queen of the village visits and announces that at least one husband has been unfaithful. What happens? （陈皓：这个问题很有限制级，哈哈，非常搞的一个问题，注意wife们的递归，这类的问题是经典的分布式通讯问题，上网搜一搜吧。）
In a country in which people only want boys, every family continues to have children until they have a boy. If they have a girl, they have another child. If they have a boy, they stop. What is the proportion of boys to girls in the country?（陈皓：第一反应是——这个国家是中国。一个概率问题，其实，无论你怎么生，50%的概率是永远不变的。）
If the probability of observing a car in 30 minutes on a highway is 0.95, what is the probability of observing a car in 10 minutes (assuming constant default probability)?
If you look at a clock and the time is 3:15, what is the angle between the hour and the minute hands? (The answer to this is not zero!)
Four people need to cross a rickety rope bridge to get back to their camp at night. Unfortunately, they only have one flashlight and it only has enough light left for seventeen minutes. The bridge is too dangerous to cross without a flashlight, and it’s only strong enough to support two people at any given time. Each of the campers walks at a different speed. One can cross the bridge in 1 minute, another in 2 minutes, the third in 5 minutes, and the slow poke takes 10 minutes to cross. How do the campers make it across in 17 minutes?（陈皓：经典的过桥问题）
You are at a party with a friend and 10 people are present including you and the friend. your friend makes you a wager that for every person you find that has the same birthday as you, you get $1; for every person he finds that does not have the same birthday as you, he gets $2. would you accept the wager?
How many piano tuners are there in the entire world?
You have eight balls all of the same size. 7 of them weigh the same, and one of them weighs slightly more. How can you find the ball that is heavier by using a balance and only two weighings?（陈皓：经典的称重问题。这样的问题花样很多，不过都不难回答）
You have five pirates, ranked from 5 to 1 in descending order. The top pirate has the right to propose how 100 gold coins should be divided among them. But the others get to vote on his plan, and if fewer than half agree with him, he gets killed. How should he allocate the gold in order to maximize his share but live to enjoy it? (Hint: One pirate ends up with 98 percent of the gold.)
You are given 2 eggs. You have access to a 100-story building. Eggs can be very hard or very fragile means it may break if dropped from the first floor or may not even break if dropped from 100th floor. Both eggs are identical. You need to figure out the highest floor of a 100-story building an egg can be dropped without breaking. The question is how many drops you need to make. You are allowed to break 2 eggs in the process. （陈皓：从3的倍数的楼层开始扔，比如3，6，9，12…..，如果鸡蛋在3n层碎了，那到在3n-1层扔第二个鸡蛋，如果没碎，则最高不碎楼层为3n- 1，否则为3n-2）
Describe a technical problem you had and how you solved it.
How would you design a simple search engine?
Design an evacuation plan for San Francisco.
There’s a latency problem in South Africa. Diagnose it. （陈皓：这个问题完全是在考你的解决问题的能力。没有明确的答案。不过，解决性能问题的第一步通常是找出瓶颈，找瓶颈有很多种方法，工具，二分查，时间记录等等。）
What are three long term challenges facing Google?
Name three non-Google websites that you visit often and like. What do you like about the user interface and design? Choose one of the three sites and comment on what new feature or project you would work on. How would you design it?
If there is only one elevator in the building, how would you change the design? How about if there are only two elevators in the building? （陈皓：经典的电梯设计问题，这种问题千变万化，主要是考你的设计能力和需求变化的适变能力，与此相似的是酒店订房系统。）
How many vacuum’s are made per year in USA?

Software Engineer

Why are manhole covers round? （陈皓：为什么下水井盖是圆的？这是有N种答案的，上Wiki看看吧）
What is the difference between a mutex and a semaphore? Which one would you use to protect access to an increment operation?
A man pushed his car to a hotel and lost his fortune. What happened? （陈皓：脑筋急转弯？他在玩大富翁游戏？！！）
Explain the significance of “dead beef”.（陈皓：要是你看到的是16进制 DEAD BEEF，你会觉得这是什么？IPv6的地址？）
Write a C program which measures the the speed of a context switch on a UNIX/Linux system.
Given a function which produces a random integer in the range 1 to 5, write a function which produces a random integer in the range 1 to 7.（陈皓：上StackOverflow看看吧，经典的问题）
Describe the algorithm for a depth-first graph traversal.
Design a class library for writing card games. （陈皓：用一系列的类来设计一个扑克游戏，设计题）
You need to check that your friend, Bob, has your correct phone number, but you cannot ask him directly. You must write a the question on a card which and give it to Eve who will take the card to Bob and return the answer to you. What must you write on the card, besides the question, to ensure Bob can encode the message so that Eve cannot read your phone number?（陈皓：协议+数字加密，我试想了一个，纸条上可以这样写，“Bob，请把我的手机号以MD5算法加密后的字符串，比对下面的字符串—— XXXXXX，它们是一样的吗？”）
How are cookies passed in the HTTP protocol?
Design the SQL database tables for a car rental database.
Write a regular expression which matches a email address. （陈皓：上StackOverflow查相当的问题吧。）
Write a function f(a, b) which takes two character string arguments and returns a string containing only the characters found in both strings in the order of a. Write a version which is order N-squared and one which is order N.（陈皓：算法题，不难，不说了。一个O(n^2)和一个O(n)的算法复杂度）
You are given a the source to a application which is crashing when run. After running it 10 times in a debugger, you find it never crashes in the same place. The application is single threaded, and uses only the C standard library. What programming errors could be causing this crash? How would you test each one? （陈皓：和随机数有关系？或是时间？）
Explain how congestion control works in the TCP protocol.
In Java, what is the difference between final, finally, and finalize?
What is multithreaded programming? What is a deadlock?
Write a function (with helper functions if needed) called to Excel that takes an excel column value (A,B,C,D…AA,AB,AC,… AAA..) and returns a corresponding integer value (A=1,B=2,… AA=26..).
You have a stream of infinite queries (ie: real time Google search queries that people are entering). Describe how you would go about finding a good estimate of 1000 samples from this never ending set of data and then write code for it.
Tree search algorithms. Write BFS and DFS code, explain run time and space requirements. Modify the code to handle trees with weighted edges and loops with BFS and DFS, make the code print out path to goal state.
You are given a list of numbers. When you reach the end of the list you will come back to the beginning of the list (a circular list). Write the most efficient algorithm to find the minimum # in this list. Find any given # in the list. The numbers in the list are always increasing but you don’t know where the circular list begins, ie: 38, 40, 55, 89, 6, 13, 20, 23, 36. （陈皓：循环排序数组的二分查找问题）
Describe the data structure that is used to manage memory. (stack)
What’s the difference between local and global variables?
If you have 1 million integers, how would you sort them efficiently? (modify a specific sorting algorithm to solve this)
In Java, what is the difference between static, final, and const. (if you don’t know Java they will ask something similar for C or C++).
Talk about your class projects or work projects (pick something easy)… then describe how you could make them more efficient (in terms of algorithms).
Suppose you have an NxN matrix of positive and negative integers. Write some code that finds the sub-matrix with the maximum sum of its elements.（陈皓：以前见过一维数组的这个问题，现在是二维的。感觉应该是把二维的第一行的最大和的区间算出来，然后再在这个基础之上进行二维的分析。思路应该是这个，不过具体的算法还需要想一想）
Write some code to reverse a string.
Implement division (without using the divide operator, obviously).（陈皓：想一想手算除法的过程。）
Write some code to find all permutations of the letters in a particular string.
What method would you use to look up a word in a dictionary? （陈皓：使用排序，哈希，树等算法和数据结构）
Imagine you have a closet full of shirts. It’s very hard to find a shirt. So what can you do to organize your shirts for easy retrieval?
You have eight balls all of the same size. 7 of them weigh the same, and one of them weighs slightly more. How can you fine the ball that is heavier by using a balance and only two weighings?
What is the C-language command for opening a connection with a foreign host over the internet?
Design and describe a system/application that will most efficiently produce a report of the top 1 million Google search requests. These are the particulars: 1) You are given 12 servers to work with. They are all dual-processor machines with 4Gb of RAM, 4x400GB hard drives and networked together.(Basically, nothing more than high-end PC’s) 2) The log data has already been cleaned for you. It consists of 100 Billion log lines, broken down into 12 320 GB files of 40-byte search terms per line. 3) You can use only custom written applications or available free open-source software.
There is an array A[N] of N numbers. You have to compose an array Output[N] such that Output[i] will be equal to multiplication of all the elements of A[N] except A[i]. For example Output[0] will be multiplication of A[1] to A[N-1] and Output[1] will be multiplication of A[0] and from A[2] to A[N-1]. Solve it without division operator and in O(n).（陈皓：注意其不能使用除法。算法思路是这样的，把output[i]=a[i]左边的乘积 x a[i]右边的乘积，所以，我们可以分两个循环，第一次先把A[i]左边的乘积放在Output[i]中，第二次把A[i]右边的乘积算出来。我们先看第一次的循环，使用迭代累积的方式，代码如下：for(r=1; i=0; i
There is a linked list of numbers of length N. N is very large and you don’t know N. You have to write a function that will return k random numbers from the list. Numbers should be completely random. Hint: 1. Use random function rand() (returns a number between 0 and 1) and irand() (return either 0 or 1) 2. It should be done in O(n).（陈皓：本题其实不难。在遍历链表的同时一边生成随机数，一边记录最大的K个随机数和其链接地址。）
Find or determine non existence of a number in a sorted list of N numbers where the numbers range over M, M>> N and N large enough to span multiple disks. Algorithm to beat O(log n) bonus points for constant time algorithm.（陈皓：使用bitmap，如果一个长整形有64位，那么我们可以使用M/64个bitmap）
You are given a game of Tic Tac Toe. You have to write a function in which you pass the whole game and name of a player. The function will return whether the player has won the game or not. First you to decide which data structure you will use for the game. You need to tell the algorithm first and then need to write the code. Note: Some position may be blank in the game। So your data structure should consider this condition also.
You are given an array [a1 To an] and we have to construct another array [b1 To bn] where bi = a1*a2*…*an/ai. you are allowed to use only constant space and the time complexity is O(n). No divisions are allowed.（陈皓：前面说过了）
How do you put a Binary Search Tree in an array in a efficient manner. Hint :: If the node is stored at the ith position and its children are at 2i and 2i+1(I mean level order wise)Its not the most efficient way.（陈皓：按顺序遍历树）
How do you find out the fifth maximum element in an Binary Search Tree in efficient manner. Note: You should not use use any extra space. i.e sorting Binary Search Tree and storing the results in an array and listing out the fifth element.
Given a Data Structure having first n integers and next n chars. A = i1 i2 i3 … iN c1 c2 c3 … cN.Write an in-place algorithm to rearrange the elements of the array ass A = i1 c1 i2 c2 … in cn（陈皓：这个算法其实就是从中间开始交换元素，代码：for(i=n-1; i>1; i++) { for(j=i; j<2*n-i; j+=2) { swap(a[j], a[j+1]); } }，不好意思写在同一行上了。）
Given two sequences of items, find the items whose absolute number increases or decreases the most when comparing one sequence with the other by reading the sequence only once.
Given That One of the strings is very very long , and the other one could be of various sizes. Windowing will result in O(N+M) solution but could it be better? May be NlogM or even better?
How many lines can be drawn in a 2D plane such that they are equidistant from 3 non-collinear points?
Let’s say you have to construct Google maps from scratch and guide a person standing on Gateway of India (Mumbai) to India Gate(Delhi). How do you do the same?
Given that you have one string of length N and M small strings of length L. How do you efficiently find the occurrence of each small string in the larger one?
Given a binary tree, programmatically you need to prove it is a binary search tree.
You are given a small sorted list of numbers, and a very very long sorted list of numbers – so long that it had to be put on a disk in different blocks. How would you find those short list numbers in the bigger one?
Suppose you have given N companies, and we want to eventually merge them into one big company. How many ways are theres to merge?
Given a file of 4 billion 32-bit integers, how to find one that appears at least twice? （陈皓：我能想到的是拆分成若干个小数组，排序，然后一点点归并起来）
Write a program for displaying the ten most frequent words in a file such that your program should be efficient in all complexity measures.（陈皓：你可能需要看看这篇文章Finding Frequent Items in Data Streams）
Design a stack. We want to push, pop, and also, retrieve the minimum element in constant time.
Given a set of coin denominators, find the minimum number of coins to give a certain amount of change.（陈皓：你应该查看一下这篇文章：Coin Change Problem）
Given an array, i) find the longest continuous increasing subsequence. ii) find the longest increasing subsequence.（陈皓：这个题不难，O(n)算法是边遍历边记录当前最大的连续的长度。）
Suppose we have N companies, and we want to eventually merge them into one big company. How many ways are there to merge?
Write a function to find the middle node of a single link list. （陈皓：我能想到的算法是——设置两个指针p1和p2，每一次，p1走两步，p2走一步，这样，当p1走到最后时，p2就在中间）
Given two binary trees, write a compare function to check if they are equal or not. Being equal means that they have the same value and same structure.（陈皓：这个很简单，使用递归算法。）
Implement put/get methods of a fixed size cache with LRU replacement algorithm.
You are given with three sorted arrays ( in ascending order), you are required to find a triplet ( one element from each array) such that distance is minimum. Distance is defined like this : If a[i], b[j] and c[k] are three elements then distance=max(abs(a[i]-b[j]),abs(a[i]-c[k]),abs(b[j]-c[k]))” Please give a solution in O(n) time complexity（陈皓：三个指针，a, b, c分别指向三个数组头，假设：a[0]b[0]，计算 abs(a[i-1] – c[0])，把结果保存在min中。现在情况变成找 a[i], b[0],c[0]，重复上述过程，如果有一个新的值比min要小，那就取代现有的min。）
How does C++ deal with constructors and deconstructors of a class and its child class?
Write a function that flips the bits inside a byte (either in C++ or Java). Write an algorithm that take a list of n words, and an integer m, and retrieves the mth most frequent word in that list.
What’s 2 to the power of 64?
Given that you have one string of length N and M small strings of length L. How do you efficiently find the occurrence of each small string in the larger one? （陈皓：我能想到的是——把那M个小字串排个序，然后遍历大字串，并在那M个字串中以二分取中的方式查找。）
How do you find out the fifth maximum element in an Binary Search Tree in efficient manner.
Suppose we have N companies, and we want to eventually merge them into one big company. How many ways are there to merge?
There is linked list of millions of node and you do not know the length of it. Write a function which will return a random number from the list.
You need to check that your friend, Bob, has your correct phone number, but you cannot ask him directly. You must write a the question on a card which and give it to Eve who will take the card to Bob and return the answer to you. What must you write on the card, besides the question, to ensure Bob can encode the message so that Eve cannot read your phone number?
How long it would take to sort 1 trillion numbers? Come up with a good estimate.
Order the functions in order of their asymptotic performance: 1) 2^n 2) n^100 3) n! 4) n^n
There are some data represented by(x,y,z). Now we want to find the Kth least data. We say (x1, y1, z1) > (x2, y2, z2) when value(x1, y1, z1) > value(x2, y2, z2) where value(x,y,z) = (2^x)*(3^y)*(5^z). Now we can not get it by calculating value(x,y,z) or through other indirect calculations as lg(value(x,y,z)). How to solve it?
How many degrees are there in the angle between the hour and minute hands of a clock when the time is a quarter past three?
Given an array whose elements are sorted, return the index of a the first occurrence of a specific integer. Do this in sub-linear time. I.e. do not just go through each element searching for that element.
Given two linked lists, return the intersection of the two lists: i.e. return a list containing only the elements that occur in both of the input lists. （陈皓：把第一个链表存入hash表，然后遍历第二个链表。不知道还没有更好的方法。）
What’s the difference between a hashtable and a hashmap?
If a person dials a sequence of numbers on the telephone, what possible words/strings can be formed from the letters associated with those numbers?（陈皓：这个问题和美国的电话有关系，大家可以试着想一下我们发短信的手机，按数字键出字母，一个组合的数学问题。）
How would you reverse the image on an n by n matrix where each pixel is represented by a bit?
Create a fast cached storage mechanism that, given a limitation on the amount of cache memory, will ensure that only the least recently used items are discarded when the cache memory is reached when inserting a new item. It supports 2 functions: String get(T t) and void put(String k, T t).
Create a cost model that allows Google to make purchasing decisions on to compare the cost of purchasing more RAM memory for their servers vs. buying more disk space.
Design an algorithm to play a game of Frogger and then code the solution. The object of the game is to direct a frog to avoid cars while crossing a busy road. You may represent a road lane via an array. Generalize the solution for an N-lane road.
What sort would you use if you had a large data set on disk and a small amount of ram to work with?
What sort would you use if you required tight max time bounds and wanted highly regular performance.
How would you store 1 million phone numbers?（陈皓：试想电话是有区段的，可以把区段统一保存，Flyweight设计模式）
Design a 2D dungeon crawling game. It must allow for various items in the maze – walls, objects, and computer-controlled characters. (The focus was on the class structures, and how to optimize the experience for the user as s/he travels through the dungeon.)
What is the size of the C structure below on a 32-bit system? On a 64-bit? （陈皓：注意编译器的对齐）

struct foo {

char a;

char* b;

};

Software Engineer in Test

Efficiently implement 3 stacks in a single array.
Given an array of integers which is circularly sorted, how do you find a given integer.
Write a program to find depth of binary search tree without using recursion.
Find the maximum rectangle (in terms of area) under a histogram in linear time.
Most phones now have full keyboards. Before there there three letters mapped to a number button. Describe how you would go about implementing spelling and word suggestions as people type.
Describe recursive mergesort and its runtime. Write an iterative version in C++/Java/Python.
How would you determine if someone has won a game of tic-tac-toe on a board of any size?
Given an array of numbers, replace each number with the product of all the numbers in the array except the number itself *without* using division.
Create a cache with fast look up that only stores the N most recently accessed items.
How to design a search engine? If each document contains a set of keywords, and is associated with a numeric attribute, how to build indices?
Given two files that has list of words (one per line), write a program to show the intersection.
What kind of data structure would you use to index annagrams of words? e.g. if there exists the word “top” in the database, the query for “pot” should list that.

Quantitative Compensation Analyst

What is the yearly standard deviation of a stock given the monthly standard deviation?
How many resumes does Google receive each year for software engineering?
Anywhere in the world, where would you open up a new Google office and how would you figure out compensation for all the employees at this new office?
What is the probability of breaking a stick into 3 pieces and forming a triangle?

Engineering Manager

You’re the captain of a pirate ship, and your crew gets to vote on how the gold is divided up. If fewer than half of the pirates agree with you, you die. How do you recommend apportioning the gold in such a way that you get a good share of the booty, but still survive?

AdWords Associate

How would you work with an advertiser who was not seeing the benefits of the AdWords relationship due to poor conversions?
How would you deal with an angry or frustrated advertisers on the phone?

Sources

http://news.ycombinator.com/item?id=266663

http://tihomir.org/crazy-questions-at-google-job-interview/

http://www.drizzle.com/~jpaint/google.html

http://www.gamedev.net/community/forums/topic.asp?topic_id=299692

http://careers.cse.sc.edu/googleinterview

http://job-interview.blogspot.com/2005/02/google-interview-product-marketing.html

http://www.theregister.co.uk/2007/01/05/google_interview_tales/

http://money.cnn.com/2007/08/29/technology/brain_teasers.biz2/index.htm

http://blogs.lessthandot.com/index.php/ITProfessionals/EthicsIT/google-interview-questions

http://placementsindia.blogspot.com/2007/09/google-top-interview-puzzles.html

http://linkmingle.com/user/interview_questions/google_interview_questions

http://discuss.joelonsoftware.com/default.asp?interview.11.626758.33

http://mindcipher.com/puzzle/78-clock-works

http://www.glassdoor.com

http://bluepixel.ca/blog/?p=69

http://www.businessinsider.com/my-nightmare-interviews-with-google-2009-11

[编程之美]N个鸡蛋放到M个篮子的方法

admin — Tue, 05 Jul 2011 15:11:13 +0000

今天看到一个面试题目，题目大意：将n个鸡蛋放到m个篮子，同时保证不能有空篮子，且对于任意小于等于n的数，都能保证有几个篮子的鸡蛋数等于这个数

题目分析

第一眼看到这个题目时，感觉像是整数拆分问题，但是有两个限制：1. 不能有空篮子 2.保证能够针对任意<=n的数，都可以用几个篮子的鸡蛋的和来表示，所以应该不是整数拆分问题。

首先想到是就是穷举，也就是深度搜索，但是如何判断搜索的一个结果是否满足第二个条件呢？

这里可以通过归纳的方法，假设当前的前n个数为Sn，同时任意<=Sn的数都可以用前n个数某些数的和来表示，那么第n+1个数的范围是什么呢？

这里应该可以想到，如果第n+1个数>(Sn) + 1 的话，相当于有间隔，那么(Sn) + 1这个就无法表示，所以第n+1个数应该是<= Sn + 1，这样就可以满足

任意的<=S(n+1) 的数都可以用前n+1个数来表示；

同时在搜索的过程中保证序列是非降序的，而且会有剪枝的方法，实现具体看代码

代码实现

CPP CODE

/*
 * Author: liyangguang 
 * http://www.yaronspace.cn/blog
 *
 * File: 1312.cc
 * Create Date: 2011-07-05 22:39:34
 *
 */
#include 
 
#define MAX_N 100000
#define MAX_M 1000
static int s_arrAns[MAX_M];
static int s_iM;
static int s_iN;
 
void
search(int iCurSum, int iIdx, int iCurNum)
{
    if (iCurSum == s_iN && iIdx == s_iM) {
 
        for (int i = 0; i < s_iM; ++i) {
            printf("%d ", s_arrAns[i]);
        }
        printf("\n");
    }
    else if (iCurSum > s_iN || iIdx >= s_iM) {
        return;
    }
    //存在两个剪枝的优化，分别放最少和最多的鸡蛋
    if ((iCurSum + iCurNum * (s_iM - iIdx)) > s_iN || iCurSum + (iCurSum +1)*((1 << (s_iM - iIdx)) - 1) < s_iN) {
        return ;
    }
    else {
        for (int i = iCurNum; i <= iCurSum + 1; ++i) {
 
            s_arrAns[iIdx] = i;
            search(iCurSum+i, iIdx+1, i);
        }
    }
}
 
int 
main(int argc, char* argv[])
{
 
    while (scanf("%d %d", &s_iN, &s_iM) != EOF) {
        search(0, 0, 1);
    }
    return 0;
}
 
 
 
/* vim: set ts=4 sw=4: */

使用mmap实现文件的拷贝

admin — Mon, 04 Jul 2011 14:13:09 +0000

今天看csapp看到了虚拟存储器的映射以及mmap函数的用法，作为练习，使用mmap来实现文件的拷贝操作，同时与传统的文件拷贝操作进行了性能比较。

mmap与munmap函数介绍：

CPP CODE

#include 
#include 
void *mmap(void *start, size_t length, int prot, int flag, int fd, off_t offset);
//返回:若成功时则返回映射区域的指针，若出错则为MAP_FAILED(-1)

start: 最好从start开始的一个区域，这个是hint，具体映射结果还是要看返回结果
length: 映射区域的大小
prot: 映射区域的访问权限位 PROT_EXEC PROT_READ PROT_WRITE PROT_NONE
flags: 映射对象的类型 MAP_ANON MAP_PRIVATE MAP_SHARED

munmap函数删除映射区域

CPP CODE

#include 
#include 
int munmap(void *start, size_t length);

实验

分别使用了mmap函数和普通的read write实现了文件的复制拷贝，下面是通过复制50M的文件性能分析：

BASH CODE

[yangguang@sim124 ~]$ time ./workspace/mmapcopy linux-20101214.tar.gz ./output    
real    0m0.100s
user    0m0.034s
sys     0m0.065s

BASH CODE

[yangguang@sim124 ~]$ time ./workspace/copy linux-20101214.tar.gz ./output
real    0m5.016s
user    0m0.000s
sys     0m0.124s

可以看到使用mmap的性能明显高于使用Read write的方式，这里主要原因是使用mmap减少了用户态和内核态间数据
的拷贝

源码分析

CPP CODE

/*
 * Author: liyangguang 
 * http://www.yaronspace.cn/blog
 *
 * File: mmapcopy.c
 * Create Date: 2011-07-04 21:02:48
 *
 */
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
 
void
mmapcopy(int src_fd, size_t src_len, int dst_fd)
{
    void *src_ptr, *dst_ptr;
    src_ptr = mmap(NULL, src_len, PROT_READ, MAP_PRIVATE, src_fd, 0);
    dst_ptr = mmap(NULL, src_len, PROT_WRITE | PROT_READ, MAP_SHARED, dst_fd, 0);
    if (dst_ptr == MAP_FAILED) {
 
        printf("mmap error:%s\n", strerror(errno));
        return;
    }
    memcpy(dst_ptr, src_ptr, src_len);
 
    munmap(src_ptr, src_len);
    munmap(dst_ptr, src_len);
}
 
 
int 
main(int argc, char* argv[])
{
    if (argc != 3) {
        printf("Usage: %s  \n", argv[0]);
        return -1;
    }
    int src_fd = open(argv[1], O_RDONLY);
    int dst_fd = open(argv[2], O_RDWR | O_CREAT | O_TRUNC);;
    struct stat stat;
    fstat(src_fd, &stat);
    truncate(argv[2], stat.st_size);
    mmapcopy(src_fd, stat.st_size, dst_fd);
    close(src_fd);
    close(dst_fd);
    return 0;
}

CPP CODE

/*
 * Author: liyangguang 
 * http://www.yaronspace.cn/blog
 *
 * File: copy.c
 * Create Date: 2011-07-04 21:38:00
 *
 */
#include 
#include 
#include 
#include 
#include 
#include 
#include 
 
void
copy(int src_fd, int dst_fd)
{
    char buffer[1024*1024];
    char *ptr = buffer;
    size_t nread, nwrite, nremain;
    while ((nread = read(src_fd, ptr, 1024*1024)) > 0) {
        nremain = nread;
        while (nremain > 0){
            nwrite = write(dst_fd, ptr, nremain);
            nremain -= nwrite; 
            ptr   = ptr + nwrite; 
        } 
        ptr = buffer;
    }
 
}
 
 
int 
main(int argc, char* argv[])
{
    if (argc != 3) {
        printf("Usage: %s  \n", argv[0]);
        return -1;
    }
    int src_fd = open(argv[1], O_RDONLY);
    int dst_fd = open(argv[2], O_RDWR | O_CREAT | O_TRUNC, S_IRWXU);;
    copy(src_fd, dst_fd);
    close(src_fd);
    close(dst_fd);
    return 0;
}
 
 
 
 
/* vim: set ts=4 sw=4: */

[编程之美]使用最大堆和最小堆来求中位数

admin — Tue, 28 Jun 2011 14:07:05 +0000

好久没更新blog，都快荒废了，今天发个算法问题

题目介绍：

输入为不断地数字流，实时显示出当前已经输入的数字序列的中位数

解答：

求中位数的方法很多，对于大数据量最经典是桶的计数方法，但是对于这个问题不适用，因为数据是不断变化的

可以用最大堆和最小堆来解答这个问题：

1.假设当前的中位数为m，其中最大堆维护的是<=m的数字序列，最小堆维护的是>=m的数字序列，但是两个堆都不包含m

2.当新的数字到达时，比如为a，将a与m进行比较，若a<=m 则将其加入到最大堆中，否则将其加入到最小堆中

3.如果此时最小堆和最大堆的元素个数的差值>=2 ，则将m加入到元素个数少的堆中，然后从元素个数多的堆将根节点赋值到m，最后重建两个最大堆和最小堆，返回到2

vim中recording模式详解

admin — Thu, 09 Jun 2011 03:08:30 +0000

今天看到这个视频：http://v.youku.com/v_show/id_XODk1NjkyNTI=.html

里面有一段是对某一行进行修改，然后可以将这些修改应用到与这一行类似的其他行，然后就想到了vim中recording模式，今天好好总结学习下。

进入recording模式

在正常状态（正常状态 = !insert状态 && !visual状态）下，按q，再按下一个字母或数字，这个数字代表缓冲区的名字，是键盘操作存储的位置，这时编辑器下方就显示”recording(记录)”字样，然后进行操作，最后按q退出这中模式，这样在这期间进行的操作就保存在缓冲区中了

生效缓冲区的内容

怎样将同样的操作在类似的行上生效呢？

使用@后面加上缓冲区的名字即可

实际例子

在文本区中存在以下内容：

int a;
int b;
int c;
int d;

然后将光标放入到第一行的第一个字符输入以下内容：qm$i=1+1q

qm：表示进入recording模式，选择缓冲区m

$i:定位到行尾并进入插入模式

=1+1：表示插入的内容

q：返回正常状态，并退出recording模式

最后将光标定位到第二行的行首，输入：@m

以下几行类似操作。

最后文本内容变为：

int a=1+1;
int b=1+1;
int c=1+1;
int d=1+1;

参考资料：http://hi.baidu.com/xiaowp/blog/item/c27b50543bb08a53574e0066.html

SMTP邮件服务器postfix配置与使用

admin — Wed, 01 Jun 2011 05:58:20 +0000

最近要帮朋友配置一个SMTP服务器，需求就是每天需要向外发送上百万封邮件，google之，发现postfix邮件服务器比较靠谱, 能够发送外部邮件，于是就选它了

操作系统：CentOS 5 32bit

postfix安装

可以通过源码安装最新的版本，但是为了方便，我直接使用yum安装

sudo yum install postfix

配置文件路径:/etc/postfix/main.cf

postfix启动与停止命令：

BASH CODE

sudo /etc/init.d/postfix start
 
sudo /etc/init.d/postfix stop
 
sudo /etc/init.d/postfix restart

postfix日志文件位置：/var/log/maillog

卸载sendmail
检查系统是否安装sendmail:

BASH CODE

rpm –qa |grep sendmail

如果存在，卸载之

BASH CODE

rpm -e sendmail --nodeps

安装cyrus-sasl-2.1.23

由于在centos 源中不存在，直接通过源码安装cyrus-sasl-2.1.23.tar.gz
下载地址
./configure &&make &&make install

这个软件包的作用就是postfix邮件服务器的认证，因为如果转发外部的邮件，必须使用smtpd_recipient_restrictions选项的值check_relay_domains或者是reject_unauth_destination，二者必须选一个，而relay_damains手工来配置允许的邮件域太麻烦，所以就选用sasl认证

修改sasl配置:/etc/sysconfig/saslauthd为

# Directory in which to place saslauthd's listening socket, pid file, and so
# on.  This directory must already exist.
START=yes
SOCKETDIR=/var/run/saslauthd

# Mechanism to use when checking passwords.  Run "saslauthd -v" to get a list
# of which mechanism your installation was compiled with the ablity to use.
#MECH="pam"
MECHANISMS="pam" #使用linux自身的用户认证

# Additional flags to pass to saslauthd on the command line.  See saslauthd(8)
# for the list of accepted flags.
#FLAGS=

然后重启saslauthd:

BASH CODE

sudo /etc/init.d/saslauthd restart

测试saslauthd生效：

BASH CODE

/usr/sbin/testsaslauthd -u liyg -p liyangguang

将sasl与postfix结合

在main.cf文件中加入：

#added by liyangguang
smtpd_recipient_restrictions = permit_mynetworks,permit_sasl_authenticated,reject_unauth_destination
#smtpd_client_restrictions = permit_sasl_authenticated

smtpd_sasl_auth_enable = yes
broken_sasl_auth_clients = yes
smtpd_sasl_security_options = noanonymous

重启postfix ：sudo /etc/init.d/postfix restart。
然后通过foxmail客户端配置smtp服务器地址，测试发送邮件是否成功

参考资料：

http://yahoon.blog.51cto.com/13184/40091

http://www.postfix.org/RESTRICTION_CLASS_README.html

http://publish.it168.com/2006/0221/20060221219401.shtml

【编程之美】单链表是否存在环以及环入口的位置【转载】

admin — Thu, 26 May 2011 14:31:25 +0000

原文地址：http://blog.csdn.net/ssfp8762/archive/2009/07/08/4331419.aspx

有一个单链表，其中可能有一个环，也就是某个节点的next指向的是链表中在它之前的节点，这样在链表的尾部形成一环。

1、如何判断一个链表是不是这类链表？

2、如果链表为存在环，如果找到环的入口点？

扩展：判断两个单链表是否相交，如果相交，给出相交的第一个点。

解答：

一、判断链表是否存在环，办法为：

设置两个指针(fast, slow)，初始值都指向头，slow每次前进一步，fast每次前进二步，如果链表存在环，则fast必定先进入环，而slow后进入环，两个指针必定相遇。

二、链表环入口的位置计算

当fast若与slow相遇时，slow肯定没有走遍历完链表，而fast已经在环内循环了n圈(1<=n)。假设slow走了s步，则fast走了2s步（fast步数还等于s 加上在环上多转的n圈），设环长为r，则：

2s = s + nr
s= nr

设整个链表长L，入口环与相遇点距离为x，起点到环入口点的距离为a。
a + x = nr
a + x = (n – 1)r +r = (n-1)r + L – a
a = (n-1)r + (L – a – x)

(L – a – x)为相遇点到环入口点的距离，由此可知，从链表头到环入口点等于(n-1)循环内环+相遇点到环入口点，于是我们从链表头、与相遇点分别设一个指针，每次各走一步，两个指针必定相遇，且相遇第一点为环入口点。

扩展问题：

判断两个单链表是否相交，如果相交，给出相交的第一个点（两个链表都不存在环）。

比较好的方法有两个：

一、将其中一个链表首尾相连，检测另外一个链表是否存在环，如果存在，则两个链表相交，而检测出来的依赖环入口即为相交的第一个点。

二、如果两个链表相交，那个两个链表从相交点到链表结束都是相同的节点，我们可以先遍历一个链表，直到尾部，再遍历另外一个链表，如果也可以走到同样的结尾点，则两个链表相交。

这时我们记下两个链表length，再遍历一次，长链表节点先出发前进(lengthMax-lengthMin)步，之后两个链表同时前进，每次一步，相遇的第一点即为两个链表相交的第一个点。

socket编程中如何区分不同的网络连接

admin — Wed, 25 May 2011 03:38:18 +0000

在网络编程中，服务器程序的代码结构一般如下：

socket() -> bind() -> listen() -> accept()

当有一个新的客户端连接时，accept建立一个新的socket，然后将sockfd返回，接下来数据的发送和接收就都在这个sockfd中进行

但是一直有一个问题我比较困惑：在服务器端，当有数据到达时，协议栈是如何将数据传递到正确的sockfd的呢（服务器端存在多个已连接的客户端）？因为不同的网络连接是使用同一个监听端口，如80端口，不可能为每一个建立的连接分配一个端口（事实也不是这样）；

上网搜寻一下，一个比较合理的解释：使用网络连接的源ip+源port来区分不同的数据连接，本身TCP协议中提供，而且可以唯一标识网络连接，因为不可能同一个客户端使用同一个端口进行来连接server的。

平面中两点的最近距离与最远距离

admin — Mon, 23 May 2011 14:04:46 +0000

今天看编程之美，看到求平面中两点的最近距离，书中给出了O(nlogn)算法，主要是采用分治的方法来做的，首先将平面的点按x坐标分为两部分，分别求最近点对，然后是合并；合并过程中对于两个点分别在两个区域的分析非常巧妙，有效地减少了需要比较的点对的个数。

在poj中对应的题目3714

然后又看到了扩展问题：如何求平面中最远的两个点的距离

这个就不能继续套用“最近距离点对”的分治策略，上网查了下，原来是使用凸包算法+旋转卡壳算法，poj中对应的题目是2187和3608

这里简单记录下，明天做下这两个题目

关于凸包算法和旋转卡壳算法的介绍：

http://yishan.cc/blogs/gpww/archive/2011/02/16/graham-s-scan.aspx

http://www.cppblog.com/staryjy/archive/2010/09/25/101412.html

http://yishan.cc/blogs/gpww/archive/2011/02/15/1787.aspx

ax操作的时间复杂度为

关于编译器字节对齐的解释与原因

admin — Thu, 19 May 2011 14:17:46 +0000

百度百科解释的比较清楚，记录下

http://baike.baidu.com/view/1523557.htm

linux中有关用户与组的命令小结

admin — Fri, 06 May 2011 06:26:52 +0000

添加用户：

BASH CODE

adduser username #添加用户
passwd username  #为用户设置密码
adduser -g groupname username #添加用户时也添加组
gpasswd -a usename groupname #将用户添加到组中

添加组：

BASH CODE

groupadd groupname # 这里不知为何与adduser的命名方式不一样

锁定用户:

BASH CODE

passwd username -l  #锁定用户
passwd username -u #解锁用户

永久删除用户：

BASH CODE

deluser username
groupdel groupname
gpasswd -d username groupname #从组groupname中删除用户username

C++沉思录读书笔记：句柄类的实现

admin — Thu, 28 Apr 2011 13:21:49 +0000

对于某些类来说，能够避免复制是很有好处的，比如某些对象会很大，复制起来消耗太大，这时就可以通过句柄（Handler）的类来实现，它允许在保持类的多态的行为的同时，还可以避免不必要的复制。

句柄类的实现方法

为了避免不必要的对象复制，也就是说允许多个句柄绑定到单个对象上，否则就很难把句柄作为参数传递函数，因为那要求复制句柄而不复制对象。因此我们必须了解有多少个句柄绑定在同一个对象上，只有这样才能确定应当在何时删除对象，通常使用“引用计数(use count)”来达到这个目的。

引用计数应该放到何处呢？

1.不能作为句柄的一部分，因为这样的话，每个句柄都必须知道跟它一起被绑定到同一个对象的其他句柄的位置，唯有如此才能更新其他句柄的引用计数数据；

2.作为对象的一部分，这样就要求我们重写已经存在的对象类；

3.定义一个新的类，来保存对象和引用计数（可以考虑）；

4.在句柄类中保存引用计数的指针地址，绑定到同一个对象的句柄指向同一个引用计数值；

5.单独抽象出引用计数类，为句柄类提供接口（终极方案）；

使用句柄类时还必须关注一个问题，当对句柄所绑定的对象进行修改时，句柄的语义就分为值语义和指针语义：

值语义：修改句柄绑定的对象，但是不影响其他句柄（使用写时复制copy-on-write）

指针语义：修改句柄绑定的对象，其他绑定到该对象的句柄也同样修改（指针的作用）

具体实现请参考C++沉思录

C++沉思录读书笔记：类设计者的核查表

admin — Tue, 26 Apr 2011 13:26:05 +0000

每一个使用C++设计类时，都有必要将下面的14条准则烂熟于心：

1. 你的类需要一个构造函数吗？

2. 你的数据成员是私有的吗？

通常公有的数据成员不是什么好事

3. 你的类需要一个无参的构造函数吗？

如果一个类已经有了构造函数，编译就不会提供默认的无参构造函数，如果需要必须显示地写一个无参的构造函数

4. 是不是每个构造函数初始化所有的数据成员？

构造函数的用途就是用一种明确定义的状态来设置对象，而对象的状态由对象的数据成员进行反应，因此构造函数都要负责为所有的数据成员设置经过明确定义的值。当然也会有写例外，类会有一些数据成员，他们只在对象存在一定时间后才会有意义。

5. 类需要析构函数吗？

应该确认类是否分配了资源，这些资源会不会由成员函数自动释放，特别那些构造函数中使用了new表达式的，通常需要在析构函数中使用delete表达式来显式地释放资源

6.类需要一个虚析构函数吗？

任何虚函数只有在继承的情况下才会有用！

7. 类需要复制构造函数吗？

通常有析构函数的类也需要一个复制构造函数！

8. 类需要一个赋值操作符吗？

9. 赋值操作符能正确地将对象赋给对象本身吗？

CPP CODE

String& String::operator =(const String& s) 
{
     if (&s != this) {
           delete[] this;
           data = new char[strlen(s.data) + 1];
           strcpy(data, s.data);
    }
    return *this;
}

10. 类需要定义关系操作符吗？
11. 删除数组时请记住用delete[]
12. 记得在复制构造函数和赋值操作符的参数类中加上const
13. 如果函数有引用参数，它们应该是const引用吗？
14. 记得适当地声明成员函数为const了吗？

redis中常用数据结构介绍

admin — Wed, 13 Apr 2011 02:56:49 +0000

1. 常用数据结构

dict

在redis中最基本的三个数据结构是dict 、adlist和sds，其中dict是redis中最重要的数据结构了，其key-value的映射关系就是通过dict来实现的，dict的内部实现是hash table，这个哈希表的大小是动态增加或减少的，主要是依据哈希表中的元素个数；同时哈希表适用链接法来解决哈希冲突的，具体实现在dict.h和dict.c文件中；

adlist

adlist(a generic doubly linked list)双向链表，这个数据结构在redis中用的也比较多，包括像当前保存的客户端连接或者是value对应是list的实现等，都是用的adlist，这个应该来说比较简单，具体实现在adlist.h和adlist.c；

sds

还有一个比较基本的数据结构就是sds(dynamic string)，对字符串处理的简单封装，具体细节实现在sds.h和sds.c中，有一篇文章是介绍sds的实现的，点击这里

2. 支持的数据类型实现

redis作为key-value数据库，value支持的类型比较多，如string, list, set, hash table, zset（有序的集合），下面简单的介绍下内部是如何实现的：

string

string就比较简单了，直接使用前面提到的sds即可，但是这里redis为了保证尽量减少内存的占用，当String代表整数值时，将其转化为long类型来存储，节约内存，具体实现请参考t_string.c文件；

list

list类型的实现使用了两种数据结构adlist和ziplist，所在文件t_list.c

ziplist: 当list的数据量< 配置文件list-max-ziplist-entries && list中元素的大小
adlist: 使用前文提到的双向链表结构，这里不再赘述

set

set的实现也是使用两种类型的数据结构，所在文件t_set.c

intset: 当集合中的元素为整数时，使用intset数据结构，内部实现就是一个整数数组，数组是有序的，具体实现请参考intset.h和intset.c文件
dict: 当集合中元素包括字符串时，必须将其转化为dict结构，key为元素值，value为NULL，这样即可在O(1)时间内判断集合中是否包含某个元素

hash table

hash table的实现也会用到两种数据结构，所在文件t_hash.c

zipmap: 使用这种结构的原因与ziplist的原因类似，节省内存，具体实现在zipmap.h和zipmap.c
dict: 前面已经介绍过，不再赘述

zset

zset有序集合，也会用到两种数据结构skip list 和dict，请参考我的上一篇blog 实现在t_zset.c中

通过看redis源码，发现其在内存优化方面确实做了不少工作，有很多可以学习的地方的~先写到这里吧。

redis中sorted set的实现原理

admin — Tue, 12 Apr 2011 09:38:00 +0000

从redis 1.1版本，redis开始支持sorted set（有序集合），今天在看redis源码时，具体看了它的实现；

关于ZSET的具体用法：http://redis.io/commands#sorted_set

ZSET的实现用到了两个数据结构：hash table 和 skip list(跳跃表)，其中hash table是具体使用redis中的dict来实现的，主要是为了保证查询效率为O(1) ，而skip list(跳跃表)主要是保证元素有序并能够保证INSERT和REMOVE操作是O(logn)的复杂度。

关于skip list这里简单介绍下：skip list是链表的一种特殊形式，对链表的一种优化；保证INSERT和REMOVE操作是O(logn)的负载读，而通用链表的复杂度为O(n);

关于skip list的详细介绍请参考下面这篇文章：

http://blog.csdn.net/caoeryingzi/archive/2010/11/18/6018070.aspx

sorted set的用途：

可以用作实时排名，例如微博用户的排名

还有TOPN问题等

http://wangyuanzju.blog.163.com/blog/static/1302920099311165490/

redis源码分析资料

admin — Fri, 08 Apr 2011 15:51:48 +0000

最近闲来无事，看看redis源码，看看redis为何如此高效~
下面是redis代码分析的资料，记录下：

比较全面但不太详细的分析：Redis: under the hood

简单的读和写的完整处理过程：More Redis internals: Tracing a GET & SET (同时也是一个挺好的GDB调试研究源码的实例教程)

关于虚拟内存：Virtual memory

其它资料：http://redis.io/documentation

那就先从redis最原始的1.0版本开始看吧，这里需要说明下，一般学习开源软件代码，最初的版本代码量比较少，看起来不是很费劲，而且基本上能够体现软件的架构信息。

有关本站redis的内容请点击这里

C++ Web编程

admin — Thu, 07 Apr 2011 13:56:28 +0000

C++ Web编程

译者 yaronli (http://www.yaronspace.cn/blog)

原文地址：http://www.tutorialspoint.com/cplusplus/cpp_web_programming.htm

什么是CGI

CGI( Common Gateway Interface )，公共网关接口是一组标准，该标准定义了在 web server和普通脚本间是如何交换信息的。

Web浏览 (Web browsing)

为了更好的理解CGI的概念，我们看看当用户为了访问某个页面或者url点击链接时所发生的事情：

你的浏览器联系到HTTP 服务器，然后请求对应的URL，即对应的文件；

Web服务器会解析这个URL，然后查找对应文件名。如果找到这个文件，Web服务器就会返回文件的内容给浏览器，否则的话会返回一条错误信息；

Web 浏览器从Web服务器获得响应信息，然后解析返回的文件内容或者是错误信息；

但是，可以这样设置HTTP服务器，当一个文件被请求时，不是将文件内容返回，而是将它作为程序来执行，并将程序产生的输出返回给你的浏览器来显示。

公共网关接口(CGI)就是这样一种协议，它使应用程序(叫做CGI程序或者是CGI脚本)能够与Web服务器交互。CGI程序可以使用Python、perl、Shell、C或者C++来编写。

CGI的架构图

下图展现了CGI的简单架构：

Web服务器的配置

在你处理CGI程序之前，请确定你的Web服务器支持CGI程序并且它配置为支持能够处理CGI程序。所有的被HTTP服务器执行CGI程序都会预先配置在规定的目录，这个目录传统上被命名为/var/www/cgi-bin/，默认情况下cgi程序的扩展名为.cgi，尽管它们是C++可执行文件。

默认情况下，Apache Web服务器的CGI程序目录被配置在/var/www/cgi-bin/。如果你想更改目录，请修改在httpd.conf中下面的片段：

   AllowOverride None
   Options ExecCGI
   Order allow,deny
   Allow from all

Options All

译者注(关于apache cgi的配置请参考http://lamp.linux.gov.cn/Apache/ApacheMenu/howto/cgi.html#page-header)

第一CGI程序

考虑下面的代码：

CPP CODE

#include 
using namespace std;
 
int main ()
{
 
   cout << "Content-type:text/html\r\n\r\n";
   cout << "\n";
   cout << "\n";
   cout << "Hello World - First CGI Program\n";
   cout << "\n";
   cout << "\n";
   cout << "Hello World! This is my first CGI program
\n";
   cout << "\n";
   cout << "\n";
 
   return 0;
}

编译上面的代码并将其命名为cpluscplus.cgi，将这个文件放置到/var/www/cgi-bin/下，在运行该程序之前，确保你使用chmod 755 cplusplus.cgi 命令来修改文件权限。现在你可以点击下面的链接cplusplus.cgi然后就会生成如下的内容：

Hello World! This is my first CGI program

面的C++程序简单将输出到STDOUT文件，在第一行输出Content-type:text/html\r\n\r\n一个额外的特点。这行被发送给浏览器并且指示在浏览器中显示的内容类型。你现在可能已经理解了CGI程序的概念了，现在你可以使用Python来编程更复杂的程序了。一个C++的CGI程序可以与外部的其他系统，如RDBM 交互信息。

HTTP头

行Content-type:text/html\r\n\r\n 作为HTTP头的一部分被发送给浏览器；所有的HTTP头都是下面的形式：

HTTP Field Name: Field Content

For Example
Content-type: text/html\r\n\r\n

行Content-type:text/html\r\n\r\n 作为HTTP头的一部分被发送给浏览器；所有的HTTP头都是下面的形式：

HTTP Field Name: Field Content

For Example

Content-type: text/html\r\n\r\n

下面的HTTP头部你可能会经常用到：

Header	Description
Content-type:	A MIME string defining the format of the file being returned. Example is Content-type:text/html
Expires: Date	The date the information becomes invalid. This should be used by the browser to decide when a page needs to be refreshed. A valid date string should be in the format 01 Jan 1998 12:00:00 GMT.
Location: URL	The URL that should be returned instead of the URL requested. You can use this filed to redirect a request to any file.
Last-modified: Date	The date of last modification of the resource.
Content-length: N	The length, in bytes, of the data being returned. The browser uses this value to report the estimated download time for a file.
Set-Cookie: String	Set the cookie passed through the string

CGI环境变量

所有的CGI程序都可以访问到下面的环境变量，这些环境变量都写任何CGI程序都非常重要。

Variable Name	Description
CONTENT_TYPE	The data type of the content. Used when the client is sending attached content to the server. For example file upload etc.
CONTENT_LENGTH	The length of the query information. It’s available only for POST requests
HTTP_COOKIE	Return the set cookies in the form of key & value pair.
HTTP_USER_AGENT	The User-Agent request-header field contains information about the user agent originating the request. Its name of the web browser.
PATH_INFO	The path for the CGI script.
QUERY_STRING	The URL-encoded information that is sent with GET method request.
REMOTE_ADDR	The IP address of the remote host making the request. This can be useful for logging or for authentication purpose.
REMOTE_HOST	The fully qualified name of the host making the request. If this information is not available then REMOTE_ADDR can be used to get IR address.
REQUEST_METHOD	The method used to make the request. The most common methods are GET and POST.
SCRIPT_FILENAME	The full path to the CGI script.
SCRIPT_NAME	The name of the CGI script.
SERVER_NAME	The server’s hostname or IP Address
SERVER_SOFTWARE	The name and version of the software the server is running.

下面的CGI程序就是显示出所有的CGI环境变量。

CPP CODE

#include 
using namespace std;
 
const string ENV[ 24 ] = {                 
        "COMSPEC", "DOCUMENT_ROOT", "GATEWAY_INTERFACE",   
        "HTTP_ACCEPT", "HTTP_ACCEPT_ENCODING",             
        "HTTP_ACCEPT_LANGUAGE", "HTTP_CONNECTION",         
        "HTTP_HOST", "HTTP_USER_AGENT", "PATH",            
        "QUERY_STRING", "REMOTE_ADDR", "REMOTE_PORT",      
        "REQUEST_METHOD", "REQUEST_URI", "SCRIPT_FILENAME",
        "SCRIPT_NAME", "SERVER_ADDR", "SERVER_ADMIN",      
        "SERVER_NAME","SERVER_PORT","SERVER_PROTOCOL",     
        "SERVER_SIGNATURE","SERVER_SOFTWARE" };   
 
int main ()
{
 
   cout << "Content-type:text/html\r\n\r\n";
   cout << "\n";
   cout << "\n";
   cout << "CGI Envrionment Variables\n";
   cout << "\n";
   cout << "\n";
   cout << "\"0\" cellspacing = \"2\">";
 
   for(int i =0; i <24; i++){cout<<"\n";}cout<<"     
   
         " << ENV[ i ] << " ";
       // attempt to retrieve value of environment variable
       char *value = getenv( ENV[ i ].c_str() );  
       if ( value != 0 ){
         cout << value;                                 
       }else{
         cout << "Environment variable does not exist.";
       }
       cout << "
   
     
<\n";
   cout << "\n";
   cout << "\n";
 
   return 0;
}

C++ CGI库

对于真实的例子，你需要通过你的CGI程序做很多操作，下面是针对C++开发来说的CGI库，ftp://ftp.gnu.org/gnu/cgicc/

BASH CODE

$tar xzf cgicc-X.X.X.tar.gz
$cd cgicc-X.X.X/
$./configure --prefix=/usr
$make
$make install

下面内容是介绍如何是CGI库来提取GET和POST方法的参数信息和如何设置cookie的，通过参考程序很好理解，暂不翻译了。

C中宏使用小贴士与小技巧[原创]

admin — Fri, 01 Apr 2011 14:12:49 +0000

C中宏使用小贴士与小技巧

译者 yaronli(http://www.yaronspace.cn/blog)

英文地址：http://www.mikeash.com/pyblog/friday-qa-2010-12-31-c-macro-tips-and-tricks.html

预处理 VS 编译

为了理解C中的宏，首先需要理解一个C程序是怎么编译的。特别的，你必须知道在预处理阶段和编译阶段发生的事情的不同之处。

就像名字所说的，预处理首先执行。它会做一些简单的文本操作，比如：

去除注释
处理#include 指令，用include文件内容对它们进行替换
判断#if 和 #ifdef指令
评估#define指令
根据已经定义#define指令，扩展哪些在剩余代码中找到的宏

显然，最后两条与今天讨论的内容最相关。

可以看到，预处理器对它所处理的文本内容并不关心。对于这点也有例外，比如，它知道这是个字符串，并不会扩展里面的的宏：

C CODE

#define SOMETHING hello
 
char *str = "SOMETHING, world!" // nope

同时它也可以计算括号的数目，所以它知道这个逗号不会传递给宏两个参数：

C CODE

#define ONEARG(x) NSLog x
 
ONEARG((@"hello, %@", @"world"));

但是通常来说，预处理器对它所处理的内容并不了解。例如，你不能使用#if来判断一个类型是否已经定义：

C CODE

// makes no sense
 
#ifndef MyInteger
 
typedef int MyInteger
 
#endif

即使MyInteger类型已经定义，#ifndef也会返回true，类型定义发现在编译阶段，此时还未发生。

同样的，对于#define定义的内容也不需要是语法正确的。下面的定义是完全合法的，尽管这是定义宏的很不好的方式：

C CODE

#define STARTLOG NSLog(
 
#define ENDLOG , "testing");
 
STARTLOG "just %" ENDLOG

预处理只是盲目地用它们定义的内容来替换STARTLOG和ENDLOG。到时编译器会使此段代码有意义，而且它确实是有意义的，完全可以编译成为有效地代码。

警告

C语言中的宏利弊并存。它们的一些特点会使它变得很危险，所以需要小心对待。

C预处理器几乎是图灵完全的。用一个简单的驱动程序，可以使用使用预处理器来计算任何可计算的函数。然而，需要做到这一点是非常怪异的扭曲和困难，以至于使图灵完整的C++模板看起来比较简单的。（不太理解）

C CODE

#define ADD(x, y) x+y
 
// produces 14, not 20
 
ADD(2, 3) * 4;
 
#define MULT(x, y) x*y
 
// produces 14, not 20
 
MULT(2 + 3, 4);

必须小心的对所有可能需要括号的地方加括号，认真对待可能传递给宏的参数和宏可能出现的场景。计算宏参数多次同样可能导致不可期望的结果：

C CODE

#define MAX(x, y) ((x) > (y) ? (x) : (y))
 
int a = 0;
 
int b = 1;
 
int c = MAX(a++, b++);
 
// now a = 1, c = 1, and b = 3!
 
// (a++ > b++ ? a++ : b++)
 
// b++ gets evaluated twice

这种使用带参数的宏和调用函数的语法非常相似，但是不要太傻了。宏需要非常小心细节的。

宏的调试

宏像其它代码一样，它们也会存在bug。宏的bug会在使用宏的地方以非常诡异的编译错误出现。这会极其让人困惑的。

为了降低迷惑，你就会想到看下预处理后的文件。这就意味着所有的宏都会展开，你会看到编译器所看到的原始的C代码，而不是仅仅扩展你的宏。由于扩展了所有的#include指令，结果文件会非常的大，但是你会在文件末尾找到你的代码。找到你宏使用的地方，弄明白宏是怎么错误的，并正确的修改。

多语句宏

写一个包含多条语句的宏是很普通的。例如：时间定义宏：

C CODE

#define TIME(name, lastTimeVariable) NSTimeInterval now = [[NSProcessInfo processInfo] systemUptime]; if(lastTimeVariable) NSLog(@"%s: %f seconds", name, now - lastTimeVariable); lastTimeVariable = now

你可以把它用在一些经常调用的函数中：

C CODE

- (void)calledALot
 
{
 
// do some work
 
// time it
 
TIME("calledALot", _calledALotLastTimeIvar);
 
}

这个定义工作地很好，但是把所有的语句写到一行是非常丑陋的。我们把它分成多行。通常#define 是在行尾结束的，但是你可以在行尾放置\ ，这样就可以使预处理器知道下一行也是定义。

C CODE

#define TIME(name, lastTimeVariable) \

NSTimeInterval now = [[NSProcessInfo processInfo] systemUptime]; \
 
if(lastTimeVariable) \
 
NSLog(@"%s: %f seconds", name, now - lastTimeVariable); \
 
lastTimeVariable = now

这样工作更简单了。但是，这个宏存在瑕疵，考虑下面的例子：

C CODE

- (void)calledALot
 
{
 
if(...) // only time some calls
 
TIME("calledALot", _calledALotLastTimeIvar);
 
}

这个宏被展开为：

C CODE

- (void)calledALot
 
{
 
if(...) // only time some calls
 
NSTimeInterval now = [[NSProcessInfo processInfo] systemUptime];
 
if(_calledALotLastTimeIvar)
 
NSLog(@"%s: %f seconds", name, now - _calledALotLastTimeIvar);
 
_calledALotLastTimeIvar = now;
 
}

这个将不会编译。将NSTimeInterval声明在if语句中是不合法的。即使能够工作，只有第一条语句是在if段中的，接下来的语句无论如何都会执行，不是我们想要的。

可以在宏定义的两端加入大括号来解决这个问题：

C CODE

#define TIME(name, lastTimeVariable) \

{ \
 
NSTimeInterval now = [[NSProcessInfo processInfo] systemUptime]; \
 
if(_calledALotLastTimeIvar) \
 
NSLog(@"%s: %f seconds", name, now - _calledALotLastTimeIvar); \
 
_calledALotLastTimeIvar = now; \
 
}

现在它展开后的样子是：

C CODE

- (void)calledALot
 
{
 
if(...) // only time some calls
 
{
 
NSTimeInterval now = [[NSProcessInfo processInfo] systemUptime];
 
if(lastTimeVariable)
 
NSLog(@"%s: %f seconds", name, now - lastTimeVariable);
 
lastTimeVariable = now;
 
};
 
}

相当不错，除了在}后面的分号了，事实上这也是个问题，考虑如下情况：

C CODE

- (void)calledALot
 
{
 
if(...) // only time some calls
 
TIME("calledALot", _calledALotLastTimeIvar);
 
else // otherwise do something else
 
// stuff
 
}

展开后的样子是：

C CODE

- (void)calledALot
 
{
 
if(...) // only time some calls
 
{
 
NSTimeInterval now = [[NSProcessInfo processInfo] systemUptime];
 
if(_calledALotLastTimeIvar)
 
NSLog(@"%s: %f seconds", name, now - _calledALotLastTimeIvar);
 
_calledALotLastTimeIvar = now;
 
};
 
else // otherwise do something else
 
// stuff
 
}

这个分号将导致语法错误。

现在你想可能想让用户使用该宏时，不要在后面加入分号。但是，这会很不自然而且对向代码自动对齐造成混乱的。

一个更好的解决方法是将代码块封装在do {…}while(0)中，这个结构需要在尾部加入一个分号，这正是我们所需要的。使用while(0)保证了这个循环永远不会执行循环，而且它的内容保证只执行一次。

C CODE

#define TIME(name, lastTimeVariable) \

do { \
 
NSTimeInterval now = [[NSProcessInfo processInfo] systemUptime]; \
 
if(lastTimeVariable) \
 
NSLog(@"%s: %f seconds", name, now - lastTimeVariable); \
 
lastTimeVariable = now; \
 
} while(0)

这个宏在if语句和其他情况下工作的很好。多语句宏通常使用do{…}while(0)封装就是这个原因。

这个宏定义了变量now，对于宏变量来说，这是不好的名字，因为可能会与外部引起冲突。考虑下面的代码:

C CODE

NSTimeInterval now; // ivar
 
TIME("whatever", now);

这个将不会工作，调试它也不是那么简单，因为这种错误太细微了。

很不幸，C语言并没有提供一个方法来生产唯一的变量名字，最好的方法就是加前缀，如下面代码：

C CODE

#define TIME(name, lastTimeVariable) \

do { \
 
NSTimeInterval MA_now = [[NSProcessInfo processInfo] systemUptime]; \
 
if(lastTimeVariable) \
 
NSLog(@"%s: %f seconds", name, MA_now - lastTimeVariable); \
 
lastTimeVariable = MA_now; \
 
} while(0)

现在这个宏就非常安全了。

字符串连接

这个功能严格上来说并不是宏的一部分，但是它对创建宏很重要，所以值得在这里提一下。在C语言中，如果你在源代码中将两个字符串放到一起，它们将进行连接，这是一个少为人知的特点。

C CODE

char *helloworld = "hello, " "world!";
 
// equivalent to "hello, world!"

你可以利用这点使用宏来讲宏参数与字符串常量进行连接：

C CODE

#define COM_URL(domain) [NSURL URLWithString: "http://www." domain ".com"];
 
COM_URL("google"); // gives http://www.google.com
 
COM_URL("apple"); // gives http://www.apple.com

字符化

通过在参数名字前加入#，预处理器会将这个参数的内容转化为C字符串，例如：

C CODE

#define TEST(condition) \

do { \
 
if(!(condition)) \
 
NSLog("Failed test: %s", #condition); \

} while(0)
 
TEST(1 == 2);
 
// logs: Failed test: 1 == 2

但是，你需要非常小心地使用。如果参数中包括了宏，它将不会被扩展。例如：

C CODE

#define WITHIN(x, y, delta) (fabs((x) - (y)) < delta)
 
TEST(WITHIN(1.1, 1.2, 0.05));
 
// logs: Failed test: WITHIN(1.1, 1.2, 0.05)

Token Pasting（不知怎么翻译）

预处理器提供了##操作符来连接token。这就允许你在宏中build多个相关的item以降低冗余。a##b将生产新的token ab，如果a 或者b是宏参数，它们的内容将会被使用。一个没有意义的例子：

C CODE

#define NSify(x) NS ## x
 
NSify(String) *s; // gives NSString

关于使用，请参考我的另一篇文章：http://www.yaronspace.cn/blog/index.php/archives/1216

变量参数列表

想像你想要写一个写日志的宏，如果全局变量被设置则记录日志：

C CODE

#define LOG(string) \

do { \
 
if(gLoggingEnabled) \
 
NSLog("Conditional log: %s", string); \
 
} while(0)

这么调用:

C CODE

LOG("hello");
//输出：
Conditional log: hello

这个非常方便，但是太简单了。NSLog接收一个字符串format和变量列表，如果LOG能够这么工作，宏才会非常有用：

C CODE

LOG("count: %d  name: %s", count, name);

如果使用原来的定义，会产生错误，宏只接收一个参数，而你确提供了三个参数。

将…置于宏参数列表的末尾，这个宏就会接受可变的参数。然后你就可以使用__VA_ARGS__标识符在宏体中使用，它会被可变参数，逗号所替代。代码如下：

C CODE

#define LOG(...) \

do { \
 
if(gLoggingEnabled) \
 
NSLog("Conditional log: " __VA_ARGS__); \
 
} while(0)

宏工作正常，但是在可变参数部分前面加一个固定的参数将会是非常有用的。例如，

C CODE

#define LOG(fmt, ...) \

do { \
 
if(gLoggingEnabled) \
 
NSLog("Conditional log: --- " fmt " ---", __VA_ARGS__); \
 
} while(0)

这样会有一个问题，你不能仅仅提供一个参数，像LOG(“hello”)，展开后为：

C CODE

NSLog(@"Conditional log: --- " "hello" " ---", );

最后一个逗号会产生语法错误。

正确的方法是使用##，如果可变参数为空，预处理会删除最后的逗号。

C CODE

#define LOG(fmt, ...) \

do { \
 
if(gLoggingEnabled) \
 
NSLog(@"Conditional log: --- " fmt " ---", ## __VA_ARGS__); \

} while(0)

特殊的标识符

C提供一些内置的标识符，在构建宏是非常有用：

__LINE__:扩展为当前行号
__FILE__:扩展为当前的源码文件
__func__:扩展为当前执行的函数名称

现在我们就可以这样定义日志宏：

C CODE

#define LOG(fmt, ...) NSLog("%s:%d (%s): " fmt, __FILE__, __LINE__, __func__, ## __VA_ARGS__)

Typeof

这是gcc一个扩展，不是标准C的，它提供表达式的类型。

使用 __typeof__, 这个宏可以这么定义:

C CODE

#define MAX(x, y) (^{ \

__typeof__(x) my_localx = (x); \
 
__typeof__(y) my_localy = (y); \
 
return my_localx &gt; my_localy ? (my_localx) : (my_localy); \
 
}())

结论

C宏复杂而强大。如果用它，一定要非常小心不要滥用。但是，在一些情况下，宏是非常有用的，利用这些小贴士和小技巧，使用宏可以使你的代码更容易些和阅读。

Pthreads并行编程之spin lock与mutex性能对比分析[zz]

admin — Tue, 29 Mar 2011 12:19:55 +0000

原文地址：http://www.parallellabs.com/2010/01/31/pthreads-programming-spin-lock-vs-mutex-performance-analysis/

Pthreads提供的Mutex锁操作相关的API主要有：
pthread_mutex_lock (pthread_mutex_t *mutex);
pthread_mutex_trylock (pthread_mutex_t *mutex);
pthread_mutex_unlock (pthread_mutex_t *mutex);

Pthreads提供的与Spin Lock锁操作相关的API主要有：
pthread_spin_lock (pthread_spinlock_t *lock);
pthread_spin_trylock (pthread_spinlock_t *lock);
pthread_spin_unlock (pthread_spinlock_t *lock);

从实现原理上来讲，Mutex属于sleep-waiting类型的锁。例如在一个双核的机器上有两个线程(线程A和线程B)，它们分别运行在 Core0和Core1上。假设线程A想要通过pthread_mutex_lock操作去得到一个临界区的锁，而此时这个锁正被线程B所持有，那么线程 A就会被阻塞(blocking)，Core0 会在此时进行上下文切换(Context Switch)将线程A置于等待队列中，此时Core0就可以运行其他的任务(例如另一个线程C)而不必进行忙等待。而Spin lock则不然，它属于busy-waiting类型的锁，如果线程A是使用pthread_spin_lock操作去请求锁，那么线程A就会一直在 Core0上进行忙等待并不停的进行锁请求，直到得到这个锁为止。

详细信息请点击：这里

linux下跨线程的越界访问hook方法

admin — Tue, 29 Mar 2011 03:03:30 +0000

我们知道在linux下多线程之间，是共用同一片存储区域的，可以访问共享的全局变量等，但是能否访问线程内部的局部变量呢，会不会出现越界异常呢？今天笔者尝试了一下，发现可以在线程间越界访问！

代码如下：

BASH CODE

/*
 * Author:yaronli <jidalyg_8711@163.com>
 * http://www.yaronspace.cn/blog
 *
 * File: hookpthread.c
 * Create Date: 2011-03-27 21:22:31
 *
 */
#include 
#include 
void * fun(void * i)
{
    int a=20;
    printf("fun: &a:[%x]-----a:[%d]\n", &a,a);
    sleep(3);
    printf("fun: &a:[%x]-----a:[%d]\n", &a,a);
    pthread_exit(NULL);
 
}
 
void * hook(void * a)
{
    int b=10;
    sleep(1);
    printf("hook: &b:[%x]\n", &b);
    printf("hook: &a:[%d]\n", *(&b-10489856/4));
    *(&b-10489856/4)=30;
    pthread_exit(NULL);
}
int main()
{
    pthread_t pidfun,pidhook;
    pthread_create(&pidfun, NULL, fun, NULL);
    pthread_create(&pidhook, NULL, hook, NULL);
    sleep(5);
    return 0;
}
/* vim: set ts=4 sw=4: */

该程序首先是在启动两个线程，在fun线程中设置局部变量a=20并显示出来，在hook线程中尝试读取a的变量值并试图更改它，然后再次显示变量a的值
在我的机器上的输出如下：

fun: &a:[419c512c]-----a:[20]
hook: &b:[423c612c]
hook: &a:[20]
fun: &a:[419c512c]-----a:[30]

可以发现a的在值在线程hook中被修改成功了，并没有出现越界访问异常

TIPS:
1. 10489856/4 关于这个值的获取是通过&b和&a的地址相减得到的，至于为什么除4，是因为&b是int型的指针，而指针的加减法的单位是4个字节，所以需要除以4，这里我也是调试好半边才搞明白的.

drupal号称比wordpress更强大

admin — Mon, 28 Mar 2011 01:42:28 +0000

drupal没有wordpress普及，但是功能应该比wordpress更强大，有以下8个用途：

项目主页：http://drupal.org

1. 文件存储分享站点
使用Drupal创建文件分享，你可以使用 CCK 和 Views ，也包括一些模块，比如Media Mover, Filebrowser 或者 Web File Manager。看看Box.net，你会非常感兴趣的^_^。

2. 社交网站
在社交网络能力方面，Drupal可能是最好的CMS。Drupal提供了强大的用户管理和权限管理系统。但是如果你想创建强大的社交网站，就需要一些模块，见http://drupal.org/node/206724。
你想看一些案例？Imbee 或者 GoingOn。

3. Twitter Clone
建议你不要尝试利用Drupal创建Twitter竞争产品，但是，如果你想整合Twitter功能到你的站点，Drupal的微博模块可以帮到你。

4. 新闻News portal
如果你想创建新闻站点或杂志站点，Drupal的完美的选择。使用CCK 和 Views ，你可以创建所有的发布内容类型，并且可灵活列表。这样的新闻站点非常之多，比如New York Observer。

5. 博客网络
用Drupal创建博客网站，很轻松，甚至无需额外模块。看看 Wisebread吧。

6. 视频分享站点
这类站点太耗带宽了，如果你决定创建，那么Drupal来帮你实现吧。FlashVideo 模块提供了创建Youtube克隆的强大能力，它整合了CCK，转换视频到FLV，并有分享代码。另外你也可以尝试Media Mover 和 SWF Tools 。MTV UK 站点就是Drupal创建的。

7. 图片分享站点
Image module ，这个模块将派上用场，可让你创建类Flickr站点，很好很强大。MyFinePix 就是Drupal创建的照片分享站点。

8. 类Digg-like news site
感谢 Drigg module, 这个模块可帮助你快速建立Digg克隆站点。流行的设计社交新闻网Designbump在使用Drupal。

linux查看系统的启动时间和运行时间

admin — Thu, 17 Mar 2011 01:46:57 +0000

1. uptime命令

输出：09:32:17 up 8:41, 1 user, load average: 0.01, 0.00, 0.00

其中8:41代表系统已经运行8小时41分

2.查看/proc/uptime

BASH CODE

[yangguang@sim124 ~]$ cat /proc/uptime 
31351.83  31341.94
#第一个数字代表已经运行的时间
 
#可以用date命令来计算出系统的启动时间
[yangguang@sim124 ~]$ date -d "$(awk -F. '{print $1}' /proc/uptime) second ago" +"%Y-%m-%d %H:%M:%S"
 
2011-03-17 00:50:51
 
#使用date命令计算系统的运行时间
[yangguang@sim124 ~]$ cat /proc/uptime| awk -F. '{run_days=$1 / 86400;run_hour=($1 % 86400)/3600;run_minute=($1 % 3600)/60;run_second=$1 % 60;printf("系统已运行：%d天%d时%d分%d秒\n",run_days,run_hour,run_minute,run_second)}'
 
系统已运行：0天8时45分27秒

字符串的哈希算法hnv的介绍和实现

admin — Wed, 16 Mar 2011 09:35:39 +0000

fnv全称”Fowler/Noll/Vo”，特点是快速而且冲突率比较低，在url hostname或者ip的哈希有广泛的应用，详细信息请点击这里

下面是fnv在Sheepdog中用法的实现，将任意字符串转化为uint64_t

C CODE

  /*
   * 64 bit FNV-1a non-zero initial basis
   */
  #define FNV1A_64_INIT ((uint64_t) 0xcbf29ce484222325ULL)
 
  /*
   * 64 bit Fowler/Noll/Vo FNV-1a hash code
   */
 static inline uint64_t fnv_64a_buf(void *buf, size_t len, uint64_t hval)
 {
     unsigned char *bp = (unsigned char *) buf;
     unsigned char *be = bp + len;
     while (bp < be) {
         hval ^= (uint64_t) *bp++;
         hval += (hval << 1) + (hval << 4) + (hval << 5) +
             (hval << 7) + (hval << 8) + (hval << 40);
     }
     return hval;
 }

sheepdog源码分析之关键模块介绍(一)

admin — Tue, 15 Mar 2011 09:37:34 +0000

1) Worker工作线程模块

该模块是作为sheepdog工作线程模块，存在多个工作线程，默认NR_WORKER_THREAD =64个工作线程；线程的入口函数为worker_routine，同时struct work_queue中pending_list是双向链表，worker_routine从该链表中读取任务，然后执行，接着将执行过的任务放到struct worker_info中finished_list双向链表，然后向main thread发送一个信号，接着调用bs_thread_request_done来执行finished_list中任务的done函数，该函数的作用是发送响应信息。涉及的文件主要是worker.c和Worker.h

struct work_queue {

int wq_state; //

int nr_active; //当前活跃的任务数目

struct list_head pending_list;//待执行的任务列表

struct list_head blocked_list; //没有用处了

};

struct worker_info {

struct list_head worker_info_siblings;//链表的连接器，目前只有一个worker_info

int nr_threads; //线程个数

pthread_mutex_t finished_lock; //

struct list_head finished_list;

/* wokers sleep on this and signaled by tgtd */

pthread_cond_t pending_cond;

/* locked by tgtd and workers */

pthread_mutex_t pending_lock;

/* protected by pending_lock */

struct work_queue q;

pthread_mutex_t startup_lock;

pthread_t worker_thread[0]; //工作线程的数据结构

};

这里需要特殊说明的是，有关任务Worker的属性WORK_SIMPLE和WORK_ORDERED，及有关block相关的函数，在0.2版本中应该是没有用处的，当时我也迷惑一阵。

Sheepdog存在三类的工作任务：

Request: 所有来自客户端或者其他sheep的请求
Recovery_work: 数据恢复任务
Delete_work: 删除vdi的任务
Cpg_event_work: 该任务作为cpg有关集群管理的任务，例如节点加入和send_message消息发送等，sheep保证当前系统只运行一个cpg_event_work任务，从sys->cpg_event_siblings中是未执行的任务。

sheepdog源码分析之关键数据结构介绍

admin — Tue, 15 Mar 2011 09:29:08 +0000

关键数据结构的说明

struct sd_req {

uint8_t proto_ver;

uint8_t opcode; //操作类型

uint16_t flags;//

uint32_t epoch;

uint32_t id;

uint32_t data_length;

uint32_t opcode_specific[8];

};

struct sd_rsp {

uint8_t proto_ver;

uint8_t opcode;

uint16_t flags;

uint32_t epoch;

uint32_t id;

uint32_t data_length;

uint32_t result;

uint32_t opcode_specific[7];

};

这两个数据结构应该是作为抽象类，可以看出sizeof(struct sd_req) == sizeof(struct sd_rsp)，这个是设计者故意为之，因为在发送请求和接收响应时，客户端是使用同一片内存区域；

struct sd_obj_req {

uint8_t proto_ver;

uint8_t opcode;

uint16_t flags;

uint32_t epoch;

uint32_t id;

uint32_t data_length;

uint64_t oid;//object id

uint64_t cow_oid;

uint32_t copies;//副本个数

uint32_t tgt_epoch;

uint64_t offset;

};

struct sd_obj_rsp {

uint8_t proto_ver;

uint8_t opcode;

uint16_t flags;

uint32_t epoch;

uint32_t id;

uint32_t data_length;

uint32_t result;

uint32_t copies;

uint32_t pad[6];

};

对object进行请求及响应，这里需要说明的一点：object在Sheepdog中作为数据存储单元，分为data_object 和vdi_object，分别存储数据和vdi的元数据，即后面提到的sheepdog_inode的内容，分片大小为4M。不知作者为何分这么小的分片？

struct sd_vdi_req {

uint8_t proto_ver;

uint8_t opcode;

uint16_t flags;

uint32_t epoch;

uint32_t id;

uint32_t data_length;

uint64_t vdi_size; //vdi的大小

uint32_t base_vdi_id;

uint32_t copies;

uint32_t snapid;

uint32_t pad[3];

};

struct sd_vdi_rsp {

uint8_t proto_ver;

uint8_t opcode;

uint16_t flags;

uint32_t epoch;

uint32_t id;

uint32_t data_length;

uint32_t result;

uint32_t rsvd;

uint32_t vdi_id;

uint32_t pad[5];

};

对vdi进行有关操作的请求和响应

struct sd_vdi_req {

uint8_t proto_ver;

uint8_t opcode;

uint16_t flags;

uint32_t epoch;

uint32_t id;

uint32_t data_length;

uint64_t vdi_size; //vdi的大小

uint32_t base_vdi_id;

uint32_t copies;

uint32_t snapid;

uint32_t pad[3];

};

struct sd_vdi_rsp {

uint8_t proto_ver;

uint8_t opcode;

uint16_t flags;

uint32_t epoch;

uint32_t id;

uint32_t data_length;

uint32_t result;

uint32_t rsvd;

uint32_t vdi_id;

uint32_t pad[5];

};

对vdi进行有关操作的请求和响应

struct sd_so_req {

uint8_t proto_ver;

uint8_t opcode;

uint16_t flags;

uint32_t epoch;

uint32_t id;

uint32_t data_length;

uint64_t oid;

uint64_t ctime;

uint32_t copies;

uint32_t tag;

uint32_t opcode_specific[2];

};

struct sd_so_rsp {

uint8_t proto_ver;

uint8_t opcode;

uint16_t flags;

uint32_t epoch;

uint32_t id;

uint32_t data_length;

uint32_t result;

uint32_t copies;

uint64_t ctime;

uint64_t oid;

uint32_t opcode_specific[2];

};

这对请求和响应的数据结构，对应的opcode为SD_OP_MAKE_FS，对整个集群进行format，并提供copies参数，指定默认的副本的个数；

struct sd_list_req {

uint8_t proto_ver;

uint8_t opcode;

uint16_t flags;

uint32_t epoch;

uint32_t id;

uint32_t data_length;

uint64_t start; //start_hval

uint64_t end; //end_hval

uint32_t tgt_epoch; //epoch参数

uint32_t pad[3];

};

struct sd_list_rsp {

uint8_t proto_ver;

uint8_t opcode;

uint16_t flags;

uint32_t epoch;

uint32_t id;

uint32_t data_length;

uint32_t result;

uint32_t rsvd;

uint64_t next;

uint32_t pad[4];

};

主要用于SD_OP_GET_OBJ_LIST操作，获得对应区间上node节点上的object list

struct sd_node_req {

uint8_t proto_ver;

uint8_t opcode;

uint16_t flags;

uint32_t epoch;

uint32_t id;

uint32_t data_length;

uint32_t request_ver;

uint32_t pad[7];

};

struct sd_node_rsp {

uint8_t proto_ver;

uint8_t opcode;

uint16_t flags;

uint32_t epoch;

uint32_t id;

uint32_t data_length;

uint32_t result;

uint32_t nr_nodes;

uint32_t local_idx;

uint32_t master_idx;

uint64_t store_size;

uint64_t store_free;

};

针对SD_OP_STAT_SHEEP和SD_OP_GET_NODE_LIST操作，获得node 详细信息，包括store_size store_free等，或者是获得node list.

struct sheepdog_inode {

char name[SD_MAX_VDI_LEN]; //vdi的名字

char tag[SD_MAX_VDI_TAG_LEN]; //tag

uint64_t ctime; // create time

uint64_t snap_ctime; //snapshot time

uint64_t vm_clock_nsec;

uint64_t vdi_size; //vdi size

uint64_t vm_state_size;

uint16_t copy_policy;

uint8_t nr_copies; //副本的个数

uint8_t block_size_shift; //data object size

uint32_t snap_id; //snapshot of this vdi

uint32_t vdi_id; //vdi id

uint32_t parent_vdi_id;

uint32_t child_vdi_id[MAX_CHILDREN];

uint32_t data_vdi_id[MAX_DATA_OBJS]; //data object id array

};

sheepdog_inode相当于sheep中存储一个镜像文件，都会存在这个结构与之对应，该结构中保存了数据object的id数组，相当与镜像文件的元数据，同时该结构会持久化保存到vid object中；

enum conn_state {

C_IO_HEADER = 0,

C_IO_DATA_INIT,

C_IO_DATA,

C_IO_END,

C_IO_CLOSED,

};

struct connection {

int fd; //sockfd

enum conn_state c_rx_state; //当前receive状态

int rx_length;

void *rx_buf;

struct sd_req rx_hdr;

enum conn_state c_tx_state; //当前transfer状态

int tx_length;

void *tx_buf;

struct sd_rsp tx_hdr;

};

struct connection结构存储socket连接的状态信息

struct client_info {

struct connection conn; //conn state

struct request *rx_req; //current rx_req

struct request *tx_req; //current tx_req

struct list_head reqs; //client 已经收到的request

struct list_head done_reqs; //已经处理完的request，待发送response

int refcnt; //引用计数，request 的个数

};

作为client保存信息，其中conn保存连接状态，reqs代表已经收到的request，done_reqs代表待发送响应的request.

enum cpg_event_type {

CPG_EVENT_CONCHG,

CPG_EVENT_DELIVER,

CPG_EVENT_REQUEST,

};

struct cpg_event {

enum cpg_event_type ctype;

struct list_head cpg_event_list;

unsigned int skip;

};

typedef void (*req_end_t) (struct request *);

struct request {

struct cpg_event cev;

struct sd_req rq;

struct sd_rsp rp;

void *data;

struct client_info *ci;

struct list_head r_siblings; //client_info->reqs

struct list_head r_wlist; //client_info->done_reqs

struct list_head pending_list; //sys->pending_list

uint64_t local_oid[2];

struct sheepdog_node_list_entry entry[SD_MAX_NODES];

int nr_nodes;

int check_consistency;

req_end_t done;

struct work work;

};

Server端请求的详细信息

struct cluster_info {

cpg_handle_t handle;

/* set after finishing the JOIN procedure */

int join_finished;

uint32_t this_nodeid;

uint32_t this_pid;

struct sheepdog_node_list_entry this_node;

uint32_t epoch;

uint32_t status;

* we add a node to cpg_node_list in confchg then move it to

* sd_node_list when the node joins sheepdog.

struct list_head cpg_node_list;

struct list_head sd_node_list;

struct list_head pending_list; //未收到响应的request

DECLARE_BITMAP(vdi_inuse, SD_NR_VDIS);

struct list_head outstanding_req_list;

struct list_head req_wait_for_obj_list;

struct list_head consistent_obj_list;

uint32_t nr_sobjs; //副本个数

struct list_head cpg_event_siblings;

struct cpg_event *cur_cevent;

unsigned long cpg_event_work_flags;

int nr_outstanding_io;

int nr_outstanding_reqs;

uint32_t recovered_epoch;

};

extern struct cluster_info *sys;

整个集群的信息

C语言中宏定义的##连接符和#转换符的用法介绍

admin — Fri, 11 Mar 2011 03:41:12 +0000

1. ##连接符的用法

在C语言中，## 连接符号由两个井号组成，其功能是在带参数的宏定义中将两个子串(token)联接起来，从而形成一个新的子串，一般跟在宏定义参数的前面。

2.#转换符的用法
#转化符是将传递的参数作为字符串来进行处理。
例如定义如下宏:

C CODE

#define pasrse( i ) printf( "token" #i " = %d", token##i ) 
//同时定义如下的变量
int token1 = 1;

则调用parse(1)的打印结果为：

#宏展开: printf("token" "1" "= %d", token1);
token1=1

3.宏定义的可变参数
在宏定义中使用可变参数，只需在参数后面加入”…”，然后使用##连接即可
例如下面的例子：

C CODE

  #define LOG_INFO(fmt, args...) \
      do {                       \
          log_write("LOG_INFO", __func__, __FILE__, __LINE__, fmt, ##args); \
      }while(0)
//其中log_write的原型为：
  void log_write(const char *level, const char *func, const char *file, int line, const char *fmt,
          ...);

sheepdog源码学习二之代码目录结构介绍

admin — Wed, 09 Mar 2011 09:19:33 +0000

目录结构

include/

config.h: 定义公共的宏
bitops.h: 有关的位操作，主要是针对oid的使用情况
util.h: 公用操作的实现
list.h: 双向链表的实现，主要是参考linux内核代码的实现
event.h: epoll异步事件模型
logger.h: 日志操作
net.h: socket网络IO
sheepdog_proto.h: sheepdog中用到的操作类型及数据结构的定义：
sheep.h: Sheep本身需要的数据结构和操作类型，与sheedog_proto.h为何分开定义暂不清楚

lib/

logger.c: 有关日志文件的操作的实现
net.c: 有关socket网络IO的实现
event.c: 事件模型的有关实现

sheep/

sheep_priv.h: 定义相关数据结构和声明相关函数
work.h: 定义工作队列对外提供的数据结构和API
work.c: 实现工作线程
sdnet.c: 对网络IO的进一步封装，包括回调函数的定义
group.c: 利用corosync对组进行管理
store.c: sheepdog有关数据存储、epoch和日志的操作
vdi.c: sheepdog中vdi的相关操作
sheep.c: sheep的main函数入口

collie/

treeview.h: vdi tree的有关操作
treeview.c: vdi tree的实现
collie.c: 对sheep进行管理实现

Vim纵向编辑模式的用法

admin — Mon, 07 Mar 2011 01:58:23 +0000

启动方法

在 Vim 命令模式下，移动游标定位于某一个位置，键入 ctrl-v后状态栏上出现 VISUAL BLOCK 字样，即进入纵向编辑模式。移动游标以按需选择待编辑的区域

我们将下面的例子来说明三种用法，序列

10.60.1.191
10.60.1.192
10.60.1.193

修改为序列：

ping -c 4 10.60.5.191 >> resultso
ping -c 4 10.60.5.192 >> resultso
ping -c 4 10.60.5.193 >> resultso

用法

1. 修改选中的列:将ip字段中的1修改为5

1>crtl – v 进入列编辑模式

2> G 移动光标至最后一行，选中所要编辑的列

3> r 进入修改模式

4> 输入数字5，并按esc退出输入模式

结果如下：

10.60.5.191
10.60.5.192
10.60.5.193

2. 前向添加：添加字符串ping -c 4

1>crtl – v 进入列编辑模式

2> G 移动光标至最后一行，可视块覆盖了第一列

3> I 进入行首插入模式

4> ping -c 4，并按esc退出输入模式

结果如下：

ping -c 4 10.60.5.191
ping -c 4 10.60.5.192
ping -c 4 10.60.5.193

3. 后添加模式：尾部追加 >> result

1>crtl – v 进入列编辑模式

2>G 移动光标至最后一行，可视块覆盖了最后一列

3> A 进入行尾插入模式

4> <

搞定….

参考资料：http://www.ibm.com/developerworks/cn/linux/l-cn-vimcolumn/index.html?ca=drs-

sheepdog源码学习笔记一

admin — Fri, 04 Mar 2011 14:05:00 +0000

最近这两天一直在看sheepdog的源码，有关sheepdog的用法，请参考我的另一篇博客：KVM分布式共享存储解决方案-sheepdog 总的来说,sheepdog的代码量不是很大，在一万行左右，比起其他的分布式文件系统如kfs,ceph等还是比较轻量级的，而且定位也是针对qemu/kvm等volume的解决方案.

sheepdog原理介绍

1. sheepdog是作为虚拟机kvm的volume使用的，是非普通的文件系统，这点和Amazon的EBS(Elastic Block Store)比较类似

2. sheepdog是一种对称(symmetric)的结构，各个节点的地位相同，没有中心节点，没有meta-server，使用Corosync 对物理节点进行管理

3. sheepdog中的对象存储分为两类，其一是One reader One Writer 其二是No writer multiple reader 而且对象是4M大小分片的，使用“一致性哈希”算法来确定对象存储位置，多副本存储

sheepdog的代码结构

./collie/treeview.c
./collie/collie.c
./sheep/vdi.c
./sheep/store.c
./sheep/sdnet.c
./sheep/work.c
./sheep/sheep.c
./sheep/group.c
./lib/logger.c
./lib/event.c
./lib/net.c

sheep目录下是有关sheepdog的大部分逻辑的处理，部署在各个节点上
collie目录是作为管理管理sheep的代码
lib目录下是关于网络、日志和事件等处理模型
…..
今天暂时写到这里……待续

编程之美的wiki页面链接

admin — Thu, 03 Mar 2011 14:00:33 +0000

下半年就找工作了，先把这个收藏了，抽时间好好研读下~

http://bop1.wikispaces.com/

linux中读写锁的rwlock介绍

admin — Mon, 28 Feb 2011 11:38:05 +0000

读写锁比mutex有更高的适用性，可以多个线程同时占用读模式的读写锁，但是只能一个线程占用写模式的读写锁；

1，当读写锁是写加锁状态时, 在这个锁被解锁之前, 所有试图对这个锁加锁的线程都会被阻塞.

2，当读写锁在读加锁状态时, 所有试图以读模式对它进行加锁的线程都可以得到访问权，但是以写模式对它进行枷锁的线程将阻塞；

3，当读写锁在读模式锁状态时, 如果有另外线程试图以写模式加锁, 读写锁通常会阻塞随后的读模式锁请求, 这样可以避免读模式锁长期占用, 而等待的写模式锁请求长期阻塞;

这种锁适用对数据结构进行读的次数比写的次数多的情况下，因为可以进行读锁共享。

API接口说明：
1)初始化和销毁

C CODE

#include 
 
int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock, const pthread_rwlockattr_t *restrict attr);
int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);
 
成功则返回0, 出错则返回错误编号.

2)读加锁和写加锁
获取锁的两个函数是阻塞操作

C CODE

#include 
 
int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);
 
成功则返回0, 出错则返回错误编号.

3)非阻塞获得读锁和写锁
非阻塞的获取锁操作, 如果可以获取则返回0, 否则返回错误的EBUSY.

C CODE

#include 
 
int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);
 
成功则返回0, 出错则返回错误编号.
//

Web开发人员必备的20款超赞的jQuery插件【CSDN】

admin — Fri, 25 Feb 2011 13:14:33 +0000

原文地址：http://sd.csdn.net/a/20110218/292102.html

收藏了

Creative Radical Web Typography

Lettering.js是一个轻量经的、易于使用的jQuery插件，可创造出极具个性的网页排版，是2010年最佳jQuery插件之一。

New FancyMoves Jquery Product Slider

Jquery Product Slider是一款效果很不错的产品幻灯片插件。

Jquery Space Gallery

Jquery Space Gallery是一款很有空间感的图片库插件。

Fancy Thumbnail Hover Effect

这是一款非常不错的Hover效果插件。

Jquery Inline Form Validation

这是一款表单验证插件。

Site Switcher

这是一款站点切换插件。

AnythingSlider

这是一款效果很棒的幻灯片插件。

Jquery Tooltip Coda Bubble

这是一款简洁的jQuery信息提示插件。

Jquery Upload and Crop Image

这是一款图片上传和裁剪插件。

jQuery Carts

这是一款jQuery图表插件。

Twitter-like login box

这是一款类似Twitter登陆框效果的插件。

File Download

这是一款文件下载插件。

Polaroid Photo Viewer

这是一款宝丽莱效果图片浏览插件。

jquery Hover Sub Tag Cloud

这是一款子标签云显示插件。

Graph Visualization

这是一款图标可视化插件。

Show/Hide Jquery Panel

这是一款控制面板显示和隐藏的插件。

Drop Down with CSS and jQuery

这是一款下拉菜单插件。

Quick & Easy Zooming With jQuery – Zoomy

这是一款非常好用的缩放插件。

Horizontal Accordions

这是一款横向手风琴效果插件。

Flexible Rating

这是一款非常灵活的评分插件。

json_encode的php实现

admin — Fri, 25 Feb 2011 09:53:44 +0000

今天coding时，需要将php中的变量返回给第三方，第一个想到就是使用json格式，方便易用。于是用了json_encode，但是发现居然报语法错误，查了手册才发现，json_enode 是在5.2.0才作为标准扩展加入php的，而我们的机器上php的版本是5.1.6，原来该扩展还未加进来。由于这个应用比较小，而且本人赖得升级php的版本，而且再手工安装这个扩展也比较麻烦，所以想到了使用php实现json_encode，原理上应该不难，找到一段代码，共享之~

代码如下：

PHP CODE


function __json_encode( $data ) {           
    if( is_array($data) || is_object($data) ) {
        $islist = is_array($data) && ( empty($data) || array_keys($data) === range(0,count($data)-1) );
 
        if( $islist ) {
            $json = '[' . implode(',', array_map('__json_encode', $data) ) . ']';
        } else {
            $items = Array();
            foreach( $data as $key => $value ) {
                $items[] = __json_encode("$key") . ':' . __json_encode($value);
            }
            $json = '{' . implode(',', $items) . '}';
        }
    } elseif( is_string($data) ) {
        # Escape non-printable or Non-ASCII characters.
        # I also put the \\ character first, as suggested in comments on the 'addclashes' page.
        $string = '"' . addcslashes($data, "\\\"\n\r\t/" . chr(8) . chr(12)) . '"';
        $json    = '';
        $len    = strlen($string);
        # Convert UTF-8 to Hexadecimal Codepoints.
        for( $i = 0; $i < $len; $i++ ) {
 
            $char = $string[$i];
            $c1 = ord($char);
 
            # Single byte;
            if( $c1 <128 ) {
                $json .= ($c1 > 31) ? $char : sprintf("\\u%04x", $c1);
                continue;
            }
 
            # Double byte
            $c2 = ord($string[++$i]);
            if ( ($c1 & 32) === 0 ) {
                $json .= sprintf("\\u%04x", ($c1 - 192) * 64 + $c2 - 128);
                continue;
            }
 
            # Triple
            $c3 = ord($string[++$i]);
            if( ($c1 & 16) === 0 ) {
                $json .= sprintf("\\u%04x", (($c1 - 224) <<12) + (($c2 - 128) << 6) + ($c3 - 128));
                continue;
            }
 
            # Quadruple
            $c4 = ord($string[++$i]);
            if( ($c1 & 8 ) === 0 ) {
                $u = (($c1 & 15) << 2) + (($c2>>4) & 3) - 1;
 
                $w1 = (54<<10) + ($u<<6) + (($c2 & 15) << 2) + (($c3>>4) & 3);
                $w2 = (55<<10) + (($c3 & 15)<<6) + ($c4-128);
                $json .= sprintf("\\u%04x\\u%04x", $w1, $w2);
            }
        }
    } else {
        # int, floats, bools, null
        $json = strtolower(var_export( $data, true ));
    }
    return $json;
}
?>

信息分析工具之—$APPEALES【转】

Yvonne — Wed, 23 Feb 2011 07:10:07 +0000

$APPEALS 是一种市场需求和收集的方法，一般是使用在市场规划和产品规划的细分市场中，因为可以从多个维度，不同的权重来分析需求，所有$APPEALS一定会联系到细分市场，联系到竞争对手，涉及到差异化分析和蓝海的价值创新(减少，增加，剔除，创新)。差异化可以说是理解市场和分析市场中的一个重要内容，只有清楚了差异化才能够树立自己产品的核心竞争力。

$APPEALS方法是IBM在IPD总结和分析出来的客户需求分析的一种方法。它从8个方面对产品进行客户需求定义和产品定位。具体如下：

$-产品价格（Price）；
A-可获得性（Availability）；
P-包装（Packaging）；
P-性能（Performance）；
E-易用性（Easy to use）；
A-保证程度（Assurances）；
L-生命周期成本（Life cycle of cost）；
S-社会接受程度（Social acceptance）。

使用客户$APPEALS框架来确定客户的欲望与需要，建立针对每一个细分市场的产品包对应图。客户$APPEALS框架的目的主要包括以下方面的内容:

处理目标细分市场的全部客户欲望与需要
建立客户驱动的需求集，作为投资的重点
确定要想在所选细分市场获得成功必须达到的主要分界标准
确定促使客户选择公司产品的主要差异

$价格
这个要素反映了客户为一个满意的产品/交付希望支付的价格。用这个标准来要求供应商时，要从实际和感觉这两方面来考虑客户能接受的购买价格。将包括以下的数据评估：技术、低成本制造、物料、人力成本、制造费用、经验、自动化程度、简易性、可生产性等。

A保证
这个要素通常反映了在可靠性、安全和质量方面的保证。用这个标准来要求供应商时，要考虑客户在可预测的环境下关于减少他/她关注确定的性能方面如何评价整个产品?这可以包括保证、鉴定、冗余度和强度。

P性能
这个要素描述了对这个交付期望的功能和特性。用这个标准来要求供应商时，要从实际和感觉这两方面来考虑有关功能和特性的产品性能。产品工作得怎样？产品是否具备所有的必须的和理想的特性？它是否提供更高的性能？从客户角度来衡量，如速度、功率、容量等。

P包装
这个要素描述了期望的设计质量、特性和外观等视觉特征。就软件而言它描述了交付或提供的功能包。用这个标准来要求供应商时，要考虑客户对外形、设计等意见，还有这些属性对交付的期望的贡献程度。关于包装的考虑应该包括样式、模块性、集成性、结构、颜色、图形、工艺设计等方面。

E易用
这个要素描述了交付的易用属性。用这个标准来要求供应商时，要考虑客户对产品的舒适、学习、文档、支持、人性化显示、感觉的输入/输出、接口、直观性等方面的考虑意见。

A可获得性
这个要素描述了客户在容易和有效两方面的购买过程(例如：让客户有他自己的方式)。用这个标准来要求供应商时，要考虑在整个购买过程的优秀程度，包括预售的技术支持和示范、购买渠道/供应商选择、交付时间、客户定制能力等。

L生命周期成本
这个要素描述了所有者在使用的整个生命周期的成本，用这个要素来要求供应商时，要考虑安装成本、培训、服务、供应、能源效率、价值折旧、处理成本等。

S社会接受程度
这个要素描述了影响购买决定的其他影响。用这个要素来要求供应商时，要考虑口头言论，第三方评价、顾问的报告、形象、政府或行业的标准、法规、社会认可、法律关系、产品义务等对购买决定起了怎样的促进作用。

对于$APPEALS方法里面涉及到很多内容，首先是要通过用户调查收集具体的用户最关心哪个维度的问题，根据这些调查数据来确定每个维度的权重；其次是要分析自己公司和竞争对手公司的产品在先阶段各个维度的评分，然后是画出相应的雷达图进行差异化分析。根据公司的战略目标和市场策略，应该重点关注哪些核心功能和核心需求，如何减少自己的弱势并提升自我优势以体现差异化，如何进行价值创新等。

提高编程技能最有效的方法[转载]

admin — Wed, 23 Feb 2011 03:38:12 +0000

看到这篇文章，感觉写的挺不错的，转载下

原文地址：http://coolshell.cn/articles/3698.html

StackExchange.com上有两个贴子（贴子一，贴子二），贴子名叫“What is the single most effective thing you did to improve your programming skills?” – 对你的编程技术提高最有效的一件事是什么？回复的人中给了很多很不错的建议，我把他们总结了一下，十条，相信一定会对你有用。（注意：顺序是我自己按我的个人经验排的）

和比自己聪明的能力比自己强的人工作。学习他们的代码，他们的做事方法，看一看那些人是怎么处理错误的。

总是倾听别人怎么说，无论那个的资历和职位是什么样的。

实践，实践，实践，总是不满意于一开始出来的事。

多问问自己，现在在写什么代码？为什么要这样写成这样？还有没有更好的方法？

学习多样的技术，多多比较他们，并一定要了解各种技术的优缺点。

总是问别人问好的问题。

多回头看看走过的路，做过的事，写过的程序，感觉一下他们有多烂。

多读读那些大师写的书。

不要总坐在电脑前编程序，多做做运动，多到户外走走，和非技术人多接触，向他们学习。

把你的想法说出去，看看别人怎么回应的。从别人的回应中学习。

除了这些，下面是我个人想给你的建议——
可能只能算精神，不能算方法。我以前也写过一篇《五个方法成为更好的程序员》，《十条不错的编程观点》，还有《优秀程序员的十个习惯》这几篇文章也能给你一些启发。

热情。对编程充满热情。这种热情会导致强烈地专研精神，和努力的精神。专研精神相当重要，它是畏难情绪的天敌。

知道。学习技术要“知其道，明其理”，而不仅仅只是了解知识。举例，为什么C++有“初始化例表”而Java却没有？为什么Java的没有多重继承？为会有了TCP还要UDP？对于一个事物，什么是好的，什么是不好的。不但要了解其表面，还要了解其思想。只有了解原始的初衷和目的，你才能真正“知道”。

犯错。不犯错误永远没有经验，从自己的错误和别人的错误中学习，只有自己犯了错，才会真正明白。犯错不可怕，可怕的是不会总结只有真正的摸爬滚打过的人才是强人。技能和经验总是用错误去换来的。

回顾。要多去回顾过去，看看历史上发生过的事。这样你才能明白事物的发展规律，从面才能了解未来的路。举例：单机 -> Client/Server -> 中间应用层 -> 多层结构 -> 分布式结构。 C -> C++ -> Java，等等，等等。未来其实就在回顾过去之中。

质疑。质疑精神很重要。质疑通常会导致不同意见甚至反对意见。也许你会质疑错，也许你会被质疑，但是你的认知也会因为不同的观点而变得完整。有所同有所不同（“同”为同意及相同），观点因为不同才能迸发出火花，事物也此而发展，世界因为不同而精彩。

C++中extern “c”深层含义

admin — Tue, 22 Feb 2011 09:22:23 +0000

extern “C” 代表双重含义：从字面意思上看，一被修饰的目标是extern,二被修饰的目标是C。

1，首先被extern “C”限定的函数或变量是extern类型的，
extern是C/C++语言中表明函数和全局变量作用范围（可见性）的关键字，该关键字告诉编译器，其声明的函数和变量可以在本模块或其它模块中使用。

2，被extern “C”修饰的变量和函数是按照C语言方式编译和连接的；

也就是说C和C++对于编译器来说编译的方式是不同的，作为面向对象程序语言，C++支持函数重载，而C语言不支持函数重载，即某个函数被C++编译器编译后和被C编译器编译后的名字是不同的。例如，函数的原型为：

void foo(int, int);

假如C++编译后的名字为：_foo_int_int

C编译后的名字为：_foo_

如果在C++中使用C语言提供的库函数时，在引用完头文件后，在链接时，可以无法再目标代码中找到_foo_int_int类似的函数，只能找到_foo_函数，所以会出现函数未定义的错误。

总的来说一句话：extern “C”的存在时为了C和C++能够进行混合编程。

关于extern “C” 的用途，请参看我的另一篇文章

C语言调用C++库接口的方法概述

参考资料：

http://www.cppblog.com/Macaulish/archive/2008/06/17/53689.html

Makefile学习笔记-wildcard notdir patsubst用法

admin — Tue, 22 Feb 2011 08:56:47 +0000

在手写Makefile时，用上这三个函数非常方便，减少了很多人力劳动哈

用法介绍：

wildcard: 扩展通配符例如将* 进行匹配

notdir: 去除目录类似于basename的用法

patsubst: 替换通配符

说起来比较费劲，直接看例子的话，比较好理解

例子介绍：

在test目录下a.cpp和b.cpp，sub目录下c.cpp和d.cpp

建立一个简单的Makefile文件：

MAKE CODE

src=$(wildcard *.c ./sub/*.c)
dir=$(notdir $(src))
obj=$(patsubst %.c，%.o，$(dir) )
 
all:
 @echo $(src)
 @echo $(dir)
 @echo $(obj)
 @echo "end"

输出结果为：

#wildcard把 指定目录 ./ 和 ./sub/ 下的所有后缀是c的文件全部展开
a.cpp b.cpp ./sub/c.cpp ./sub/d.cpp
#notdir把展开的文件去除掉路径信息
a.cpp b.cpp c.cpp d.cpp
#patsubst把$(dir)中的变量符合后缀是.c的全部替换成.o
a.o b.o c.o d.o

sscanf函数的高级用法[转载]

admin — Sat, 19 Feb 2011 09:47:08 +0000

原文地址：http://blog.csdn.net/eroswang/archive/2007/08/20/1751444.aspx

大家都知道sscanf是一个很好用的函数，利用它可以从字符串中取出整数、浮点数和字符串等等。它的使用方法简单，特别对于整数和浮点数来说。但新手可能并不知道处理字符串时的一些高级用法，这里做个简要说明吧。
名称:

sscanf() – 从一个字符串中读进与指定格式相符的数据.

函数原型:

Int sscanf( string str, string fmt, mixed var1, mixed var2 … );

int scanf( const char *format [,argument]… );

说明：

sscanf与scanf类似，都是用于输入的，只是后者以屏幕(stdin)为输入源，前者以固定字符串为输入源。
其中的format可以是一个或多个 {%[*] [width] [{h | l | I64 | L}]type | ‘ ‘ | ‘\t’ | ‘\n’ | 非%符号}

注：

1、 * 亦可用于格式中, (即 %*d 和 %*s) 加了星号 (*) 表示跳过此数据不读入. (也就是不把此数据读入参数中)

2、{a|b|c}表示a,b,c中选一，[d],表示可以有d也可以没有d。

3、width表示读取宽度。

4、{h | l | I64 | L}:参数的size,通常h表示单字节size，I表示2字节 size,L表示4字节size(double例外),l64表示8字节size。

5、type :这就很多了，就是%s,%d之类。

6、特别的：%*[width] [{h | l | I64 | L}]type 表示满足该条件的被过滤掉，不会向目标参数中写入值

支持集合操作：

%[a-z] 表示匹配a到z中任意字符，贪婪性(尽可能多的匹配)

%[aB'] 匹配a、B、’中一员，贪婪性

%[^a] 匹配非a的任意字符，贪婪性

1. 常见用法。

char str[512] = {0};

sscanf(“123456 “, “%s”, str);

printf(“str=%s\n”, str);

2. 取指定长度的字符串。如在下例中，取最大长度为4字节的字符串。

sscanf(“123456 “, “%4s”, str);

printf(“str=%s\n”, str);

3. 取到指定字符为止的字符串。如在下例中，取遇到空格为止字符串。

sscanf(“123456 abcdedf”, “%[^ ]“, str);

printf(“str=%s\n”, str);

4. 取仅包含指定字符集的字符串。如在下例中，取仅包含1到9和小写字母的字符串。

sscanf(“123456abcdedfBCDEF”, “%[1-9a-z]“, str);

printf(“str=%s\n”, str);

5. 取到指定字符集为止的字符串。如在下例中，取遇到大写字母为止的字符串。

sscanf(“123456abcdedfBCDEF”, “%[^A-Z]“, str);

printf(“str=%s\n”, str);

不是以空格作为分割符的话，多数是用5,6,7这种用法

因为，字符串匹配到空格为止

6、给定一个字符串iios/12DDWDFF@122，获取 / 和 @ 之间的字符串，先将 “iios/”过滤掉，再将非‘@’的一串内容送到buf中

sscanf(“iios/12DDWDFF@122“, “%*[^/]/%[^@]“, buf);

printf(“%s\n”, buf);

结果为：12DDWDFF

7、给定一个字符串““hello, world”，仅保留world。（注意：“，”之后有一空格）

sscanf(“hello, world”, ”%*s %s”, buf);

printf(“%s\n”, buf);

结果为：world

%*s表示第一个匹配到的%s被过滤掉，即hello被过滤了

如果没有空格则结果为NULL。

sscanf的功能很类似于正则表达式, 但却没有正则表达式强大,所以如果对于比较复杂的字符串处理,建议使用正则表达式.

下面示例显示如何使用 sscanf() C 运行时库函数来读取内部缓冲区分隔带有逗号 (,) 字段。密钥是用于格式是 sscanf() 函数中括号。格式将是 % ['、'] 它告诉函数以从缓冲区读取，直到到达逗号 (,) ^,。

示例代码

C CODE

/* The following sample illustrates the use of brackets and the
caret (^) with sscanf().
Compile options needed: none
*/
#include 
#include 
#include 
char *tokenstring = "first,25.5,second,15";
int result, i;
double fp;
char o[10], f[10], s[10], t[10];
void main()
{
result = sscanf(tokenstring, "%[^','],%[^','],%[^','],%s", o, s, t, f);
fp = atof(s);
i  = atoi(f);
printf("%s\n %lf\n %s\n %d\n", o, fp, t, i);
}

有一些小体会：
对于sscanf的格式化串，规律为
1.%前面的字符为跳过的字符，如果要跳过多个字符，应全部放在%之前；
2.^为读取的字符串，后面所跟字符为截至字符；
3.^须用[]括起，所以一定要核对[]符号的数量

gdb调试程序之调试宏的方法[六]

admin — Thu, 17 Feb 2011 09:52:34 +0000

在GCC编译程序的时候，加上-ggdb3参数，这样，你就可以调试宏了。

另外，你可以使用下述的GDB的宏调试命令来查看相关的宏。

info macro_name – 查看这个宏在哪些文件里被引用了，以及宏定义是什么样的。
macro_name – 查看宏展开的样子。

KVM可扩展性测试报告

admin — Wed, 16 Feb 2011 09:21:57 +0000

KVM可扩展性测试报告

by yaonli(http://www.yaronspace.cn/blog)

测试设计

对KVM虚拟机可扩展性测试，主要是指随着虚拟机的数量的增加，虚拟机的在CPU利用率、内存使用、磁盘IO和网络IO的性能是否表现良好，最后能够给出在物理机一定硬件条件下，可运行的虚拟机的数目的最佳指标。

在具体的设计方案上，在物理机上分别启动1到16个虚拟机，然后从CPU利用率、磁盘IO和网络IO三个方面进行分析，这里需要说明下没有测试内存使用的情况的原因：针对KVM来说，分配给虚拟机的内存大小是事先指定，加入分配512M内存，则虚拟机的物理内存就是512M内存，分析意义不大；

1， CPU利用率测试上

在测试虚拟机CPU利用率方面，主要是CPU密集型的软件进行测试，计算最终的执行时间；例如内核的编译或者bzip2对大文件进行压缩，都是CPU计算性。本次测试选用bzip2 对1.8G的镜像文件进行压缩，计算最终的执行时间。

date+%s.%N && bzip2 –9 windows_2003_server.img && date +%s.%N

2，磁盘IO测试

测试磁盘IO的话，我选择用的是Bonnie++ 软件，并发地从虚拟机1台到16台的进行测试，执行命令如下：

./bonnie++ -d ~/test –s 1000

3，网络IO测试

鉴于如果使用网卡类型如rtl8139或者e1000，效率非常低，所以本次测试网卡类型都是基于virtio网卡类型，然后并发地从物理机到1到16台虚拟机进行并发通信，主要是利用nertperf软件进行测试.

测试环境

物理主机硬件配置

1， 8核Intel(R) Xeon(R) CPU E5410 @ 2.33GHz

2， 16G内存

3， 1.4T硬盘

4，千兆以太网卡

物理主机的软件配置

1，64Bit CentOS 5.3 2.6.18-128.el5

2，kvm-88

虚拟机分配的硬件配置

1，单核CPU

2， 512M内存

3， Virtio 网卡

4， qcow2 format 增量镜像

虚拟机的软件配置

1，8.04 ubuntu系统

测试数据

1， CPU执行时间

上面这图例说明，随着虚拟机数目的增加，CPU执行时间在5-9虚拟机时呈现一种稳定的状态，但是当虚拟机达到10个时，CPU执行时间呈现较大的增长，然后在10-12个虚拟机时呈现稳定装填，当虚拟机数目到达13以上，CPU时间呈增长趋势。

第一个这个图例说明，在虚拟机的数目达到8个时，执行bzip命令的时间基本上是相同的，也就是说在CPU调度方面达到了均衡，平均分配CPU时间；但是在虚拟机的数目达到9个时，每个虚拟机的CPU执行时间出现了波动，有的执行的时间长，有的执行时间短，CPU没有达到调度平衡。

2，网络IO数据

由实验数据可知，使用virtio技术，虚拟机的网络吞吐，随着虚拟机数量的增加，实际网络IO基本达到理想的网络IO的水平，即如果物理网卡是千兆网卡，虚拟机的网络IO吞吐为100M/n，n代表同一台物理机上虚拟机的数量.

3，磁盘IO数据

上面两个图分别代表对虚拟机进行磁盘的Block Read Write操作的结果，由图可知，磁盘的并发写操作的效率随着虚拟机数目的增加下降的快，而并发读操作下降的不是很明显，当虚拟机的数目达到10时，磁盘的并发读操作急剧下降，可以作为分隔点 (Bonnie++ 软件把字符和块测试放到一起，这里我只列出了block读写的数据，测试数据是否准确有待进一步验证)。

结论

通过对虚拟机的CPU执行时间、网络IO和磁盘IO的测试，在现有硬件条件支持下，KVM虚拟机的数量在维持在8-10个是较稳定的状态，各个虚拟机的衡量指标达到比较稳定的值。

在这种物理主机硬件配置条件下

1， 8核Intel(R) Xeon(R) CPU E5410 @ 2.33GHz

2， 16G内存

3， 1.4T硬盘

4，千兆以太网卡

建议KVM虚拟机的配置:

1，单核CPU （多核性能未测试）

2， 1G内存（物理内存完全可以满足需求，所有可以开的大一些）

3，百兆网卡 virtio

单台物理机启动虚拟机的数目在8-10左右，建议为8个虚拟机

linux监控程序-程序自动重启方法

admin — Mon, 24 Jan 2011 03:11:41 +0000

大家在写server的时候，不管server写的是多么健壮，还是经常出现core dump等程序异常退出的，但是一般情况下需要在无人为干预情况下，能够自动重新启动，保证server程序能够服务用户。这时就需要一个监控程序来实现能够让程序自动重新启动，现在笔者在写portmap就遇到了这个问题，通过网上查找资料，找到了一个相对靠谱的exec+fork解决方法。

使用脚本实现自动重启

首先想到的最简单的使用shell脚本，大概思路：

ps -ef | grep “$1″ | grep -v “grep” | wc –l 是获取 $1 （$1 代表进程的名字）的进程数，脚本根据进程数来决定下一步的操作。通过一个死循环，每隔 1 秒检查一次系统中的指定程序的进程数，这里也可使用crontab来实现。

这种方法比较土，还是可以基本解决问题，但是有1s的延迟，笔者在应用中未采用这种方法，有关这个shell脚本，请参看文章后面的附件代码。

exec+fork方式

笔者最终采用的exec+fork方式来实现的，具体思想如下：

1，exec函数把当前进程替换为一个新的进程，新进程由path或file参数指定。可以使用exec函数将程序的执行从一个程序切换到另一个程序；

2，fork函数是创建一个新的进程，在进程表中创建一个新的表项，而创建者（即父进程）按原来的流程继续执行，子进程执行自己的控制流程；

3，wait 当fork启动一个子进程时，子进程就有了它自己的生命周期并将独立运行，我们可以在父进程中调用wait函数让父进程等待子进程的结束；

相信介绍到这里，读者已经能够想到解决方法了：1)首先使用fork系统调用，创建子进程，2)在子进程中使用exec函数，执行需要自动重启的程序，3) 在父进程中执行wait等待子进程的结束，然后重新创建一个新的子进程。

使用方法：

BASH CODE

#./portmap 需要监控的程序的路径
#args portmap 需要的参数
$ ./supervisor ./portmap  args.....

代码如下：

C CODE

/**
 *
 * supervisor 
 *
 * author: liyangguang (liyangguang@software.ict.ac.cn)
 *
 * date: 2011-01-21 21:04:01
 *
 * changes
 * 1, execl to execv
 */
 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
 
int
main(int argc, char **argv)
{
    int ret, i, status;
    char *child_argv[100] = {0};
    pid_t pid;
    if (argc < 2) {
 
        fprintf(stderr, "Usage:%s  \n", argv[0]);
        return -1;
    }
    for (i = 1; i < argc; ++i) {
        child_argv[i-1] = (char *)malloc(strlen(argv[i])+1);
        strncpy(child_argv[i-1], argv[i], strlen(argv[i]));
        child_argv[i-1][strlen(argv[i])] = '\0';
    }
    while(1){
 
        pid = fork(); 
        if (pid == -1) {
            fprintf(stderr, "fork() error.errno:%d error:%s\n", errno, strerror(errno));
            break;
        }
        if (pid == 0) {
            ret = execv(child_argv[0], (char **)child_argv);
            //ret = execl(child_argv[0], "portmap", NULL, 0);
            if (ret < 0) {
                fprintf(stderr, "execv ret:%d errno:%d error:%s\n", ret, errno, strerror(errno));
                continue;
            }
            exit(0);
        }
 
        if (pid > 0) {
            pid = wait(&status);
 
            fprintf(stdout, "wait return");
        }
 
    }
 
 
    return 0;
}

shell脚本方式的代码如下：

BASH CODE

# 函数: CheckProcess
# 功能: 检查一个进程是否存在
# 参数: $1 --- 要检查的进程名称
# 返回: 如果存在返回0, 否则返回1.
#------------------------------------------------------------------------------
CheckProcess()
{
  # 检查输入的参数是否有效
  if [ "$1" = "" ];
  then
    return 1
  fi
 
  #$PROCESS_NUM获取指定进程名的数目，为1返回0，表示正常，不为1返回1，表示有错误，需要重新启动
  PROCESS_NUM=`ps -ef | grep "$1" | grep -v "grep" | wc -l` 
  if [ $PROCESS_NUM -eq 1 ];
  then
    return 0
  else
    return 1
  fi
}
 
 
# 检查test实例是否已经存在
while [ 1 ] ; do
 CheckProcess "test"
 CheckQQ_RET=$?
 if [ $CheckQQ_RET -eq 1 ];
 then
 
# 杀死所有test进程，可换任意你需要执行的操作
 
 
  killall -9 test
  exec ./test &  
 fi
 sleep 1
done

端口映射工具portmap 0.1版本发布

admin — Thu, 20 Jan 2011 09:28:03 +0000

项目地址：http://code.google.com/p/portmap/

下载地址：http://portmap.googlecode.com/files/portmap-0.1.tar.gz

项目介绍：

portmap 主要是作为各个机器间端口映射的工具
项目的最初目的是作为vnc端口映射，主要是将不同机器的vnc接口映射到一台能够对外的
物理机上，安全和方便管理；
iptables可以实现端口映射，但是每次增加一个映射端口都需要重新启动，故自己动手完成了端口映射工具；
还有像80端口的映射，这个可以归总为反向代理，作为负载均衡器来使用，原理是相通，像nginx七层的负载均衡功能应该使用的就是端口映射，portmap暂时不支持哈~

特点：

* 使用epoll方式，支持高并发和长连接模式
* 多线程支持，线程个数可配置，主要作为工作线程
* 使用简单，只需发送待映射的端口到守护进程，守护进程会返回映射后的端口，即可使用
*

TODO:

* 配置文件单独提取出来
* bug修复
* 多机扩展？

Example:

SHELL CODE

$ make
$ ./portmap  //启动进程
$ cd test    //修改test1.c中相关变量

C CODE

   //addr: portmap server的地址
  //port: portmap server 的端口
  //request:是需要映射的地址和端口
const char *addr = "10.60.1.124";
unsigned int port = 5903;
 
const char *request = "10.60.1.124:5905";

BASH CODE

make && ./test1

正常情况下，返回映射后的地址和端口

gdb 调试多进程程序方法

admin — Wed, 12 Jan 2011 13:04:44 +0000

今天在用gdb调试sheepdog时，在程序fork出子进程后，整个gdb程序就退出了，无法继续跟踪，网上找了半天找到了解决方法.

解决方法：

设置detach-on-fork参数

set detach-on-fork [on|off]

on: 断开调试follow-fork-mode指定的进程。
off: gdb将控制父进程和子进程。follow-fork-mode指定的进程将被调试，另一个进程置于暂停（suspended）状态

将detach-on-fork 设置为off即可

跟踪子进程的方法：

默认情况下，gdb会继续跟踪父亲进程，无法对子进程进行调试

设置follow-fork-mode可以解决这个问题

follow-fork-mode的用法为：

set follow-fork-mode [parent|child]

parent: fork之后继续调试父进程，子进程不受影响。
child: fork之后调试子进程，父进程不受影响。

SHELL CODE

(gdb) set follow-fork-mode child

本文地址：http://www.yaronspace.cn/blog/index.php/archives/1072

KVM分布式共享存储解决方案-sheepdog

admin — Mon, 10 Jan 2011 13:52:04 +0000

介绍

今天在调研分布式文件系统时，非常偶然的机会看到sheepdog ，然后接着又看到KVM这个关键字，让我异常兴奋，这不是我一直在找的KVM镜像存储的分布式存储系统吗，原来KVM/Qemu最近已经开始对其进行了开发，并在Qemu 0.13.0版本后加入了与sheepdog的支持，太佩服国外的开源贡献者。

sheepdog(牧羊犬) 官方网站：http://www.osrg.net/sheepdog/

Sheepdog is a distributed storage system for KVM. It provides highly available block level storage volumes that can be attached to KVM virtual machines. Sheepdog scales to several hundreds nodes, and supports advanced volume management features such as snapshot, cloning, and thin provisioning.

安装步骤

1，环境准备

corosync-1.3.0.tar.gz sheepdog-0.2.0.tar.gz

2，安装corosync

corosync 是linux 集群管理的引擎，具体请参看官网

SHELL CODE

$ tar -xzvf  corosync-1.3.0.tar.gz
$ cd corosync-1.3.0
$ ./autogen.sh
$ ./configure
$ sudo make install

3，qemu 0.13的安装（略）

4，sheepdog安装

SHELL CODE

$ tar -xzvf sheepdog-0.2.0.tar.gz
$ cd sheepdog-0.2.0
$ ./autogen.sh
$ ./configure
$ sudo make install

这时可能会出现linux/signalfd.h 这个文件找不到，以及后续会出现signalfd undefined reference 的错误，我的系统是CentOS ，出现了这种错误，出现这种情况的话，我简单的解决方法是对signalfd进行模拟，这点我参考了qemu的有关实现，
具体是在sheep/work.c中加入以下代码：
代码太长，我贴到最后了，请参看附件

5，sheepdog的具体使用

1> 配置/etc/corosync/corosync.conf
mv /etc/corosync/corosync.conf.example /etc/corosync/corosync.conf
同时修改，bindnetaddr字段为自己的ip地址，mcastaddr（怎么修改暂时不清楚，应该是广播的地址，保持默认值即可）
2> 启动corosync
# corosync {注：需要是root账户}
3> 如果是ext3文件系统，需要加入user_xattr

SHELL CODE

     mount -o remount,user_xattr /

4> 启动Sheep

SHELL CODE

      # sheep ~/store_dir  #不能是相对路径，相对路径会出错
      # collie cluster format --copies=3

5> 查看状态

SHELL CODE

      # collie node list
      # collie cluster info
      # colli vdi list

6> 创建镜像

SHELL CODE

        # qemu-img create sheepdog:Alice 256G
        # qemu-img convert ~/amd64.raw sheepdog:Bob

不过我在Convert时一直提示不成功，error while writing
查找原因：通过查看sheep.log日志文件，可以发现时由于Too Many open files 错误提示，原来是打开太多文件所造成的，因为sheepdog对文件进行4M进行分片的，这样会导致大量的文件打开，而一般的系统进程最多的文件数是1024 所以就这个错误！
解决方法：ulimit -n 4096 {或者更大的值} 这样修改只是在目前会话中有效，需要长久生效，请参看这篇文章

总结

sheepdog作为一个新的项目，感觉还是挺不错的，刚好弥补了开源虚拟化中有关镜像存储的问题，为后续的虚拟机迁移做准备，目前sheepdog暂时还未支持migrate ，不过看它的TODO LIST 下一步已经开始做了，系统能够尽快做出来，下一步主要是看下它的源码，因为很多地方会出现诡异的错误的，还需要解决呀！

本文地址：http://www.yaronspace.cn/blog/index.php/archives/1065

附件代码：

C CODE

#ifndef  _SIGNALFD
#include
 
 
/*
 *  include/linux/signalfd.h
 *
 *  Copyright (C) 2007  Davide Libenzi
 *
 */
 
/* For O_CLOEXEC and O_NONBLOCK */
#include
 
 
/* Flags for signalfd4.  */
#define SFD_CLOEXEC O_CLOEXEC
#define SFD_NONBLOCK O_NONBLOCK
 
struct signalfd_siginfo {
        __u32 ssi_signo;
        __s32 ssi_errno;
        __s32 ssi_code;
        __u32 ssi_pid;
        __u32 ssi_uid;
        __s32 ssi_fd;
        __u32 ssi_tid;
        __u32 ssi_band;
        __u32 ssi_overrun;
        __u32 ssi_trapno;
        __s32 ssi_status;
        __s32 ssi_int;
        __u64 ssi_ptr;
        __u64 ssi_utime;
        __u64 ssi_stime;
        __u64 ssi_addr;
 
        /*
         * Pad strcture to 128 bytes. Remember to update the
         * pad size when you add new members. We use a fixed
         * size structure to avoid compatibility problems with
         * future versions, and we leave extra space for additional
         * members. We use fixed size members because this strcture
         * comes out of a read(2) and we really don't want to have
         * a compat on read(2).
         */
        __u8 __pad[48];
};
 
void qemu_set_cloexec(int fd)
{
    int f;
    f = fcntl(fd, F_GETFD);
    fcntl(fd, F_SETFD, f | FD_CLOEXEC);
}
struct sigfd_compat_info
{
    sigset_t mask;
    int fd;
};
 
static void *sigwait_compat(void *opaque)
{
    struct sigfd_compat_info *info = opaque;
    int err;
    sigset_t all;
 
    sigfillset(&amp;all);
    sigprocmask(SIG_BLOCK, &amp;all, NULL);
 
    do {
        siginfo_t siginfo;
 
        err = sigwaitinfo(&amp;info-&gt;mask, &amp;siginfo);
        if (err == -1 &amp;&amp; errno == EINTR) {
            err = 0;
            continue;
        }
 
        if (err &gt; 0) {
            char buffer[128];
            size_t offset = 0;
 
            memcpy(buffer, &amp;err, sizeof(err));
            while (offset &lt; sizeof(buffer)) {
                ssize_t len;
 
                len = write(info-&gt;fd, buffer + offset,
                            sizeof(buffer) - offset);
                if (len == -1 &amp;&amp; errno == EINTR)
                    continue;
 
                if (len &lt;= 0) {
                    err = -1;
                    break;
                }
 
                offset += len;
            }
        }
    } while (err &gt;= 0);
 
    return NULL;
}
 
static int qemu_signalfd_compat(const sigset_t *mask)
{
    pthread_attr_t attr;
    pthread_t tid;
    struct sigfd_compat_info *info;
    int fds[2];
 
    info = malloc(sizeof(*info));
    if (info == NULL) {
        errno = ENOMEM;
        return -1;
    }
 
    if (pipe(fds) == -1) {
        free(info);
        return -1;
    }
 
    qemu_set_cloexec(fds[0]);
    qemu_set_cloexec(fds[1]);
 
    memcpy(&amp;info-&gt;mask, mask, sizeof(*mask));
    info-&gt;fd = fds[1];
 
    pthread_attr_init(&amp;attr);
    pthread_attr_setdetachstate(&amp;attr, PTHREAD_CREATE_DETACHED);
 
    pthread_create(&amp;tid, &amp;attr, sigwait_compat, info);
 
    pthread_attr_destroy(&amp;attr);
 
    return fds[0];
}
#endif

KVM虚拟机在物理机间的迁移方法

admin — Wed, 05 Jan 2011 06:00:31 +0000

有关虚拟机间的动态迁移，我在虚拟机迁移技术漫谈对它进行大概的介绍，现在结合今天我自身的实践，来具体解释下迁移的步骤；

1，环境准备

1) 共享存储-NFS: 理论上来说，需要迁移的虚拟机可以不适用共享存储，但是如果不用共享存储的话，在迁移的过程中就需要对镜像进行大量的拷贝，这个是非常耗时的，而且在大量的集群的情况下，基本上镜像都是存放在分布式的共享存储中，一是方便管理，一是为虚拟机的动态迁移做准备，有关NFS的使用和挂载，请参看我的另外一篇文章
CentOS配置NFS服务器的方法
2) 支持kvm迁移的qemu-kvm 和 kvm模块：我用的是最新的qemu-kvm-0.13.0.tar.gz ，而kvm模块，由于我的系统的内核版本过低，用的kvm-88中的kvm-intel.ko kvm.ko模块

2，启动kvm虚拟机

在下面的介绍中使用源虚拟机是待迁移的虚拟机，目的虚拟机是迁移后的虚拟机
源主机的启动命令如下：

SHELL CODE

   ./qemu-system-x86_64 -m 512 -hda /home/yangguang/nfs_mnt/images/debian_lenny_i386_small.qcow2 -net tap -net nic,model=rtl8139 -vnc :1 -monitor stdio
    #解释说明：
     1,  /home/yangguang/nfs_mnt: 代表NFS挂载的目录
     2,  -monitor stdio  将控制台定向的标准输入输出(这个是虚拟机迁移必须的，因为后续需要在命令行中进行操作)

目的虚拟机的启动命令：

SHELL CODE

    ./qemu-system-x86_64 -m 512 -hda /home/yangguang/nfs_mnt/images/debian_lenny_i386_small.qcow2 -net tap -net nic,model=rtl8139 -vnc :1 -monitor stdio -incoming tcp:0:8888
     #解释说明
     1,  启动命令参数必须和源虚拟机的启动参数是一样的，包括网卡类型等
     2,  -incoming tcp:0:8888 这个是在端口8888接收迁移命令和数据

这时在命令行中输入

SHELL CODE

     info status

源虚拟机显示的状态是running
目的虚拟机的显示的状态时paused

3，进行虚拟机迁移

在源虚拟机中的控制台中执行以下命令：

SHELL CODE

    (qemu) help migrate
migrate [-d] [-b] [-i] uri -- migrate to URI (using -d to not wait for completion)
                         -b for migration without shared storage with full copy of disk
                         -i for migration without shared storage with incremental copy of disk (base image shared between src and destination)
     (qemu) migrate   -d tcp:10.60.1.92:8888
      #info migrate  查看当前的迁移的执行状态
     (qemu) info migrate

执行完成后，可以通过info status命令来看
源虚拟机和目的虚拟机的状态
这时源虚拟机的状态:paused
目的虚拟机的状态:running
此时迁移完成，源虚拟机就可以退出了(quit)
同时可以在迁移期间，可以在另外一个主机上使用ping命令对迁移的主机进行联通性进行测试，看看虚拟机的中断时间
长短。

4，总结

到此为止，有关虚拟机的迁移已经完成，但是要把KVM虚拟机的迁移应该到实际的环境中，还需要关注下虚拟机迁移过程虚拟机内部服务的中间时间，以及整个虚拟机迁移的时间；同时目前我比较关心的是分布式共享存储的解决方案，NFS肯定是不能解决问题的，不知大家有没有好的解决方案？

一年又一年

admin — Sun, 02 Jan 2011 14:48:52 +0000

今天已经是2011年，真的感觉时间过的好快呀，转眼的功夫一年又过去了，每个人都需要停下脚步，回过头看看这一年的得与失，真的需要好好总结下了。
看到我的去年的总结，还是有种很亲切的感觉，没事写写平时的感受其实还是挺好的，可惜总是贴一些技术的文章，个人的想法的东西去想的还是太少（可能是性格的因素的吧，不希望把一些比较内心的想法表达出来），这个其实真的还是蛮好的，争取2011年能够写一些。
简单的列下流水账吧，太有文采的文字也写不出来
1，今年开学直到九月份一直在百度实习，实习是瞒着老板偷偷地出去的，时间还是挺紧凑的，还得正常去实验室，只能利用上课的时间去公司，基本上研一下半年没有上过课，不过最后还好，课程都过了，呵呵！其实本来没有打算出去实习的，真的想好好利用研究生的时间搞搞科研，正像在Google面试那个工程师所说的那样，既然读了研究生，就应该做一些与正常本科毕业就工作的不一样的事情，如果研究生三年就是再外面实习三年，虽然最后也可能找到很好的工作，但肯定还不如直接工作三年来的更直接一些呢，所以研究生就应该做一些研究生应该做的一些事，比如读读paper、写写论文啥的等；但是我最后还是选择出去实习，主要原因是原来跟着老板做的东西不感兴趣，不能就这样荒废三年对吧，而且我觉得我不是能够主动去学习的那种，需要某种需求进行推动我，我才会去看它学习它的，所以就偷偷摸摸的在百度实习了将近半年。
总的来说，在百度这半年还是挺开心的，挺有收获的，主要参与了Baidu App Engine 项目主要开发工作，因为这个项目是比较新的项目，当时去的时候，加我一共三个人，能够接触比较多的东西，从前端到最后端，而且对整个架构也理解的比较清晰，后来陆续又来了两个同事，这项目在百度内部目前发展的比较好，有个比较有意思的小插曲：当时我将近实习结束，我的mentor居然劝我退学，放弃读硕士，直接工作，并且拿出自己当例子说事（他是硕士毕业，但是我们的项目老大是本科毕业，而且比他还低一届），可惜我最后还是乖乖的回所继续干活了，哈哈~最后还是感谢chuanying,xiaowei还有dongfei zhangyong这些同学的，从你们身上学到了很多！
2，到九月份时，就乖乖的回实验室了，开始了我的正常的研究生生涯，到现在也将近三四个月了，做了一些东西，包括对KFS的改造，有关KVM虚拟机的学习等，这期间我居然开始修改内核代码了，这个是最难以置信的，不过还是太弱了，本科时学的体系结构和微机技术的知识基本上全忘没了，还得从头回忆，但是还真没觉得这个东西能够用到，但是看论文太少，自己的独立思考还太弱了。
3，生活上，十一的时候去了趟大城市铁岭，看望下丈母娘，话说这男女方如果不在同一个地方，真是比较麻烦，下次去不知道得等到啥时候，这结婚后就更纠结了，希望xiaofang同学看到不要有啥想法哦~
同时也给超哥、猛哥和韬哥提醒一声，找对象尽量都找近一点哦

2011年的期望：
1，祝愿小邓同学早日实现她的梦想

2，好好干活与学习，明年找个好工作
3，希望lc lm zt (对号入座)不再寂寞不再mensao, 猛哥也越nb, 超哥和韬哥飞越成功，我和猛哥的儿子的前途就全靠你俩了
写了好多，我发现我也太能墨迹了，不写了，回去睡觉了

CentOS配置NFS服务器的方法

admin — Fri, 31 Dec 2010 07:29:53 +0000

最近搞KVM虚拟机迁移，前提是需要一个共享存储的文件系统来存储系统镜像，本来打算使用KFS来作为分布式文件系统的，但是在修改kvm的镜像读写API后，系统是跑起来了，但是奇慢无比，主要是存在对镜像存在大量的随机读写造成的，这个下次再好好总结下。所以就想到了简单易用的NFS文件系统，下面是具体的配置细节：

1，NFS服务器的安装

在CentOS系统中，默认情况下已经安装了NFS文件系统，如果没有安装就需要手工安装了

#rpm –q nfs-utils portmap

2，查看NFS是否启动

#service nfs starus
#service portmap status

3，启动NFS

#service nfs start
#service portmap status

4，修改NFS系统配置文件

#vim /etc/exports

/home/yaronli/nfs_space *(sync,rw)

解释说明：

/home/yaronli/nfs_space：共享目录名
*：表示所有主机都可以连接改NFS
(sync,rw):设置选项

    sync：设置NFS服务器同步写磁盘，这样不会轻易丢失数据，建议所有的NFS共享目录都使用该选项
    ro：设置输出的共享目录只读，与rw不能共同使用
   rw：设置输出的共享目录可读写，与ro不能共同使用

exports文件中“客户端主机地址”字段可以使用多种形式表示主机地址

    192.168.152.13　指定IP地址的主机
    nfsclient.test.com　指定域名的主机
    192.168.1.0/24　指定网段中的所有主机
   *.test.com　指定域下的所有主机
    *　所有主机

5，生效配置文件
命令#exportfs –rv 可以让新设置的exports文件内容生效
以上是Server端的配置步骤

Client端的配置步骤如下：
1，直接mount到nfs server即可

# mount -t nfs 10.60.1.91:/home/yangguang/nfs_space  /mnt/
说明：
10.60.1.91:是nfs server的ip地址
/home/yangguang/nfs_space: 是nfs server中的共享目录
/mnt:为本地的目录

执行成功后，即可在/mnt目录中看到nfs server 挂载的内容
2，卸载已经挂载的nfs共享目录

#umount /mnt/

常用命令：

显示当前主机中NFS服务器的输出列表
# showmount -e
显示当前主机NFS服务器中已经被NFS客户机挂载使用的共享目录
# showmount -d
显示NFS服务器的输出
# showmount -e 10.60.1.91

本文地址：http://www.yaronspace.cn/blog/index.php/archives/1051

C语言调用C++库接口的方法概述

admin — Tue, 28 Dec 2010 09:30:12 +0000

最近需要在由纯c语言编写的代码中调用C++的动态库，在网上找了一些资料，现在总结下解决方法。

主要的思想就是将C++的动态库再封装一层，在这一层编写C语言的函数api，这API中使用C++动态库提供的类；

具体例子如下：

1，假如C++动态库包含如下代码：
//myclass.h

C CODE

#ifndef _MYCLASS_H
#define _MYCLASS_H
class MyClass
{
    public:
        void print();
};
#endif

//myclass.cc

C CODE

#include 
#include "myclass.h"
using namespace std;
 
void
MyClass::print()
{
    cout << "MyClass::print() called" << endl;
}

编译链接生成动态库：libmyclass.so
g++ myclass.cc -shared -o libmyclass.so -I./ -fPIC

2，封装libmyclass.so中类的接口，生成libmyfunc.so
//myfunc.h

C CODE

#ifndef _MYFUNCTION_H
#define _MYFUNCTION_H
 
#ifdef _cplusplus
extern "C" {
#endif
    void myprint();
#ifdef _cplusplus
}
#endif
#endif

//myfunc.c

C CODE

#include "myclass.h"
#ifndef _cplusplus
#define _cplusplus
#include "myfunc.h"
#endif
void
myprint()
{
    MyClass mc;
    mc.print();
}

编译链接生成动态库（C语言接口）:
g++ myfunc.c -shared -o libmyfunc.so -L./ -lmyclass -fPIC -Xlinker -rpath=./
3，测试libmyfunc.so中提供的接口
//main.c

C CODE

#include "myfunc.h"
int 
main(int argc, char **argv)
{
    myprint(); 
}

编译链接生成可执行代码：
gcc main.c -o main -lmyfunc -L./ -I. -Xlinker -rpath=./
执行main文件，输出如下：
MyClass::print() called
ok，大功搞成！！
注意事项：
1，注意myfunc.so必须是用g++来生成的，如果使用gcc，会不识别其中的类(这个解释不一定正确)
2，注意myfunc.h中_cpluscplus的用法，因为myfunc.h被main.c和myfunc.c两个文件用到，而extern仅被g++能够识别，
而不能够被gcc识别，解释的不一定对，还没有想清楚。。。。。
本文地址：http://www.yaronspace.cn/blog/index.php/archives/1046

使用事件驱动模型实现高效稳定的网络服务器程序【写得比较基础详细】

admin — Thu, 23 Dec 2010 14:35:20 +0000

前言

事件驱动为广大的程序员所熟悉，其最为人津津乐道的是在图形化界面编程中的应用；事实上，在网络编程中事件驱动也被广泛使用，并大规模部署在高连接数高吞吐量的服务器程序中，如 http 服务器程序、ftp 服务器程序等。相比于传统的网络编程方式，事件驱动能够极大的降低资源占用，增大服务接待能力，并提高网络传输效率。

关于本文提及的服务器模型，搜索网络可以查阅到很多的实现代码，所以，本文将不拘泥于源代码的陈列与分析，而侧重模型的介绍和比较。使用 libev 事件驱动库的服务器模型将给出实现代码。

阻塞型的网络编程接口

几乎所有的程序员第一次接触到的网络编程都是从 listen()、send()、recv() 等接口开始的。使用这些接口可以很方便的构建服务器 / 客户机的模型。

我们假设希望建立一个简单的服务器程序，实现向单个客户机提供类似于“一问一答”的内容服务。
图 1. 简单的一问一答的服务器 / 客户机模型

我们注意到，大部分的 socket 接口都是阻塞型的。所谓阻塞型接口是指系统调用（一般是 IO 接口）不返回调用结果并让当前线程一直阻塞，只有当该系统调用获得结果或者超时出错时才返回。

实际上，除非特别指定，几乎所有的 IO 接口 ( 包括 socket 接口 ) 都是阻塞型的。这给网络编程带来了一个很大的问题，如在调用 send() 的同时，线程将被阻塞，在此期间，线程将无法执行任何运算或响应任何的网络请求。这给多客户机、多业务逻辑的网络编程带来了挑战。这时，很多程序员可能会选择多线程的方式来解决这个问题。

多线程的服务器程序

应对多客户机的网络应用，最简单的解决方式是在服务器端使用多线程（或多进程）。多线程（或多进程）的目的是让每个连接都拥有独立的线程（或进程），这样任何一个连接的阻塞都不会影响其他的连接。

具体使用多进程还是多线程，并没有一个特定的模式。传统意义上，进程的开销要远远大于线程，所以，如果需要同时为较多的客户机提供服务，则不推荐使用多进程；如果单个服务执行体需要消耗较多的 CPU 资源，譬如需要进行大规模或长时间的数据运算或文件访问，则进程较为安全。通常，使用 pthread_create () 创建新线程，fork() 创建新进程。

我们假设对上述的服务器 / 客户机模型，提出更高的要求，即让服务器同时为多个客户机提供一问一答的服务。于是有了如下的模型。
图 2. 多线程的服务器模型

在上述的线程 / 时间图例中，主线程持续等待客户端的连接请求，如果有连接，则创建新线程，并在新线程中提供为前例同样的问答服务。

很多初学者可能不明白为何一个 socket 可以 accept 多次。实际上，socket 的设计者可能特意为多客户机的情况留下了伏笔，让 accept() 能够返回一个新的 socket。下面是 accept 接口的原型：

	 int accept(int s, struct sockaddr *addr, socklen_t *addrlen);

输入参数 s 是从 socket()，bind() 和 listen() 中沿用下来的 socket 句柄值。执行完 bind() 和 listen() 后，操作系统已经开始在指定的端口处监听所有的连接请求，如果有请求，则将该连接请求加入请求队列。调用 accept() 接口正是从 socket s 的请求队列抽取第一个连接信息，创建一个与 s 同类的新的 socket 返回句柄。新的 socket 句柄即是后续 read() 和 recv() 的输入参数。如果请求队列当前没有请求，则 accept() 将进入阻塞状态直到有请求进入队列。

上述多线程的服务器模型似乎完美的解决了为多个客户机提供问答服务的要求，但其实并不尽然。如果要同时响应成百上千路的连接请求，则无论多线程还是多进程都会严重占据系统资源，降低系统对外界响应效率，而线程与进程本身也更容易进入假死状态。

很多程序员可能会考虑使用“线程池”或“连接池”。“线程池”旨在减少创建和销毁线程的频率，其维持一定合理数量的线程，并让空闲的线程重新承担新的执行任务。“连接池”维持连接的缓存池，尽量重用已有的连接、减少创建和关闭连接的频率。这两种技术都可以很好的降低系统开销，都被广泛应用很多大型系统，如 websphere、tomcat 和各种数据库等。

但是，“线程池”和“连接池”技术也只是在一定程度上缓解了频繁调用 IO 接口带来的资源占用。而且，所谓“池”始终有其上限，当请求大大超过上限时，“池”构成的系统对外界的响应并不比没有池的时候效果好多少。所以使用“池” 必须考虑其面临的响应规模，并根据响应规模调整“池”的大小。

对应上例中的所面临的可能同时出现的上千甚至上万次的客户端请求，“线程池”或“连接池”或许可以缓解部分压力，但是不能解决所有问题。

总之，多线程模型可以方便高效的解决小规模的服务请求，但面对大规模的服务请求，多线程模型并不是最佳方案。下一章我们将讨论用非阻塞接口来尝试解决这个问题。

非阻塞的服务器程序

以上面临的很多问题，一定程度是 IO 接口的阻塞特性导致的。多线程是一个解决方案，还一个方案就是使用非阻塞的接口。

非阻塞的接口相比于阻塞型接口的显著差异在于，在被调用之后立即返回。使用如下的函数可以将某句柄 fd 设为非阻塞状态。

	 fcntl( fd, F_SETFL, O_NONBLOCK );

下面将给出只用一个线程，但能够同时从多个连接中检测数据是否送达，并且接受数据。
图 3. 使用非阻塞的接收数据模型

在非阻塞状态下，recv() 接口在被调用后立即返回，返回值代表了不同的含义。如在本例中，

recv() 返回值大于 0，表示接受数据完毕，返回值即是接受到的字节数；
recv() 返回 0，表示连接已经正常断开；
recv() 返回 -1，且 errno 等于 EAGAIN，表示 recv 操作还没执行完成；
recv() 返回 -1，且 errno 不等于 EAGAIN，表示 recv 操作遇到系统错误 errno。

可以看到服务器线程可以通过循环调用 recv() 接口，可以在单个线程内实现对所有连接的数据接收工作。

但是上述模型绝不被推荐。因为，循环调用 recv() 将大幅度推高 CPU 占用率；此外，在这个方案中，recv() 更多的是起到检测“操作是否完成”的作用，实际操作系统提供了更为高效的检测“操作是否完成“作用的接口，例如 select()。

使用 select() 接口的基于事件驱动的服务器模型

大部分 Unix/Linux 都支持 select 函数，该函数用于探测多个文件句柄的状态变化。下面给出 select 接口的原型：

 FD_ZERO(int fd, fd_set* fds)
 FD_SET(int fd, fd_set* fds)
 FD_ISSET(int fd, fd_set* fds)
 FD_CLR(int fd, fd_set* fds)
 int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds,
        struct timeval *timeout)

这里，fd_set 类型可以简单的理解为按 bit 位标记句柄的队列，例如要在某 fd_set 中标记一个值为 16 的句柄，则该 fd_set 的第 16 个 bit 位被标记为 1。具体的置位、验证可使用 FD_SET、FD_ISSET 等宏实现。在 select() 函数中，readfds、writefds 和 exceptfds 同时作为输入参数和输出参数。如果输入的 readfds 标记了 16 号句柄，则 select() 将检测 16 号句柄是否可读。在 select() 返回后，可以通过检查 readfds 有否标记 16 号句柄，来判断该“可读”事件是否发生。另外，用户可以设置 timeout 时间。

下面将重新模拟上例中从多个客户端接收数据的模型。
图 4. 使用 select() 的接收数据模型

上述模型只是描述了使用 select() 接口同时从多个客户端接收数据的过程；由于 select() 接口可以同时对多个句柄进行读状态、写状态和错误状态的探测，所以可以很容易构建为多个客户端提供独立问答服务的服务器系统。
图 5. 使用 select() 接口的基于事件驱动的服务器模型

这里需要指出的是，客户端的一个 connect() 操作，将在服务器端激发一个“可读事件”，所以 select() 也能探测来自客户端的 connect() 行为。

上述模型中，最关键的地方是如何动态维护 select() 的三个参数 readfds、writefds 和 exceptfds。作为输入参数，readfds 应该标记所有的需要探测的“可读事件”的句柄，其中永远包括那个探测 connect() 的那个“母”句柄；同时，writefds 和 exceptfds 应该标记所有需要探测的“可写事件”和“错误事件”的句柄 ( 使用 FD_SET() 标记 )。

作为输出参数，readfds、writefds 和 exceptfds 中的保存了 select() 捕捉到的所有事件的句柄值。程序员需要检查的所有的标记位 ( 使用 FD_ISSET() 检查 )，以确定到底哪些句柄发生了事件。

上述模型主要模拟的是“一问一答”的服务流程，所以，如果 select() 发现某句柄捕捉到了“可读事件”，服务器程序应及时做 recv() 操作，并根据接收到的数据准备好待发送数据，并将对应的句柄值加入 writefds，准备下一次的“可写事件”的 select() 探测。同样，如果 select() 发现某句柄捕捉到“可写事件”，则程序应及时做 send() 操作，并准备好下一次的“可读事件”探测准备。下图描述的是上述模型中的一个执行周期。
图 6. 一个执行周期

这种模型的特征在于每一个执行周期都会探测一次或一组事件，一个特定的事件会触发某个特定的响应。我们可以将这种模型归类为“事件驱动模型”。

相比其他模型，使用 select() 的事件驱动模型只用单线程（进程）执行，占用资源少，不消耗太多 CPU，同时能够为多客户端提供服务。如果试图建立一个简单的事件驱动的服务器程序，这个模型有一定的参考价值。

但这个模型依旧有着很多问题。

首先，select() 接口并不是实现“事件驱动”的最好选择。因为当需要探测的句柄值较大时，select() 接口本身需要消耗大量时间去轮询各个句柄。很多操作系统提供了更为高效的接口，如 linux 提供了 epoll，BSD 提供了 kqueue，Solaris 提供了 /dev/poll …。如果需要实现更高效的服务器程序，类似 epoll 这样的接口更被推荐。遗憾的是不同的操作系统特供的 epoll 接口有很大差异，所以使用类似于 epoll 的接口实现具有较好跨平台能力的服务器会比较困难。

其次，该模型将事件探测和事件响应夹杂在一起，一旦事件响应的执行体庞大，则对整个模型是灾难性的。如下例，庞大的执行体 1 的将直接导致响应事件 2 的执行体迟迟得不到执行，并在很大程度上降低了事件探测的及时性。
图 7. 庞大的执行体对使用 select() 的事件驱动模型的影响

幸运的是，有很多高效的事件驱动库可以屏蔽上述的困难，常见的事件驱动库有 libevent 库，还有作为 libevent 替代者的 libev 库。这些库会根据操作系统的特点选择最合适的事件探测接口，并且加入了信号 (signal) 等技术以支持异步响应，这使得这些库成为构建事件驱动模型的不二选择。下章将介绍如何使用 libev 库替换 select 或 epoll 接口，实现高效稳定的服务器模型。

使用事件驱动库 libev 的服务器模型

Libev 是一种高性能事件循环 / 事件驱动库。作为 libevent 的替代作品，其第一个版本发布与 2007 年 11 月。Libev 的设计者声称 libev 拥有更快的速度，更小的体积，更多功能等优势，这些优势在很多测评中得到了证明。正因为其良好的性能，很多系统开始使用 libev 库。本章将介绍如何使用 Libev 实现提供问答服务的服务器。

（事实上，现存的事件循环 / 事件驱动库有很多，作者也无意推荐读者一定使用 libev 库，而只是为了说明事件驱动模型给网络服务器编程带来的便利和好处。大部分的事件驱动库都有着与 libev 库相类似的接口，只要明白大致的原理，即可灵活挑选合适的库。）

与前章的模型类似，libev 同样需要循环探测事件是否产生。Libev 的循环体用 ev_loop 结构来表达，并用 ev_loop( ) 来启动。

	 void ev_loop( ev_loop* loop, int flags )

Libev 支持八种事件类型，其中包括 IO 事件。一个 IO 事件用 ev_io 来表征，并用 ev_io_init() 函数来初始化：

	 void ev_io_init(ev_io *io, callback, int fd, int events)

初始化内容包括回调函数 callback，被探测的句柄 fd 和需要探测的事件，EV_READ 表“可读事件”，EV_WRITE 表“可写事件”。

现在，用户需要做的仅仅是在合适的时候，将某些 ev_io 从 ev_loop 加入或剔除。一旦加入，下个循环即会检查 ev_io 所指定的事件有否发生；如果该事件被探测到，则 ev_loop 会自动执行 ev_io 的回调函数 callback()；如果 ev_io 被注销，则不再检测对应事件。

无论某 ev_loop 启动与否，都可以对其添加或删除一个或多个 ev_io，添加删除的接口是 ev_io_start() 和 ev_io_stop()。

	 void ev_io_start( ev_loop *loop, ev_io* io )
	 void ev_io_stop( EV_A_* )

由此，我们可以容易得出如下的“一问一答”的服务器模型。由于没有考虑服务器端主动终止连接机制，所以各个连接可以维持任意时间，客户端可以自由选择退出时机。
图 8. 使用 libev 库的服务器模型

上述模型可以接受任意多个连接，且为各个连接提供完全独立的问答服务。借助 libev 提供的事件循环 / 事件驱动接口，上述模型有机会具备其他模型不能提供的高效率、低资源占用、稳定性好和编写简单等特点。

由于传统的 web 服务器，ftp 服务器及其他网络应用程序都具有“一问一答”的通讯逻辑，所以上述使用 libev 库的“一问一答”模型对构建类似的服务器程序具有参考价值；另外，对于需要实现远程监视或远程遥控的应用程序，上述模型同样提供了一个可行的实现方案。

总结

本文围绕如何构建一个提供“一问一答”的服务器程序，先后讨论了用阻塞型的 socket 接口实现的模型，使用多线程的模型，使用 select() 接口的基于事件驱动的服务器模型，直到使用 libev 事件驱动库的服务器模型。文章对各种模型的优缺点都做了比较，从比较中得出结论，即使用“事件驱动模型”可以的实现更为高效稳定的服务器程序。文中描述的多种模型可以为读者的网络编程提供参考价值。

Google创新论坛

Yvonne — Sun, 12 Dec 2010 14:58:24 +0000

WPO[Web 性能优化与运维]会议链接

admin — Sun, 12 Dec 2010 14:26:53 +0000

http://velocity.oreilly.com.cn/index.php?func=slidesvideos

保存下链接，后续好好听下~

linux中container_of用法详解

admin — Sat, 11 Dec 2010 07:49:35 +0000

今天看内核代码，发现container_of的用法，上网查下它的用法，原来是 在已知结构体的某个成员的指针时，求出整个结构体的首指针地址，具体宏展开如下：

C CODE

#define container_of(ptr, type, member) ({ \

const typeof( ((type *)0)->member ) *__mptr = (ptr); \
 
(type *)( (char *)__mptr - offsetof(type,member) );})

具体解释如下：
typeof是gcc的一个扩展，用于确定一个变量的类型，有点像C++的RTTI，常用于表达式内的语句，在定义宏时，如果需要临时变量，可以这样做：

C CODE

#define max(a,b) \
({ typeof (a) _a = (a); \
typeof (b) _b = (b); \
_a > _b ? _a : _b; })

它可以保证我们定义的变量_a/_b与宏传入的变量a/b类型匹配，而不会产生编译器告警。

因此container_of的第一行就是定义一个与member类型匹配的变量__mptr，赋值后，__mptr为宏参数中的待转换指针，因为只是类型转换，不涉及数据读写，((type*)0)是没有任何副作用的。

第二行用__mptr减去member变量在type中的偏移，这样便可实际访问到ptr相同偏移，也即type的实际首地址了。offsetof有两种定义：

C CODE

#ifdef __compiler_offsetof
#define offsetof(TYPE,MEMBER) __compiler_offsetof(TYPE,MEMBER)
#else
#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
#endif

__compiler_offsetof即__builtin_offsetof，__builtin_offsetof可能是gcc內建的支持(见gcc源码c-parser.c)，
从后一种实现方式可以明显看到这一技巧，假定一个从0地址开始的结构体，取其成员member的地址正是结构体内的偏移。

linux下的c语言的宏果然是博大精深呀，还得学习，下次会介绍下有关模块注册中宏的用法的~

许式伟：架构之美&软件质量保障

admin — Tue, 07 Dec 2010 13:34:26 +0000

第一次拜访客户

Yvonne — Mon, 06 Dec 2010 13:56:19 +0000

今天下午第一次拜访客户收集需求，我的感受主要有三点：

首先，直观的了解客户需要一个什么样的功能：以前听别人转述可以知道我们要实现怎样的功能，

但通常都包含了转述人对需求加工的成分，如果描述不完整还容易造成理解的偏差；今天直接听到了客户对需求的描述，我要注意自己转述的时候别扭曲了用户的原意。

其次，知道客户提出某个需求做什么用、将如何使用：客户描述了实际使用中遇到的问题，所以希望这个功能怎样怎样实现以解决这个问题。

这样便于我们理解客户提出的需求，并且站在客户的角度思考功能的实现方式。可以在一定程度上避免做出来的产品是客户不需要的，或者不符合客户的使用习惯。

最后，客户能帮助我们排除他们不会使用的场景：前期我们项目组内讨论需求时大家都尽量覆

盖猜想到的使用场景和实现方式，与客户沟通的时候他们直接回答“我们不会这么用”。

另外客户和咨询师也会顺便给出一些对产品的反馈。并且是单纯的学习产品功能不考虑用户实际使用场景时不会考虑到的。

总之收益匪浅，以后能力提高了还要主动提供解决方案供参考，以后的事儿明天再说，今天回家了先~~

需求分析小试牛刀【1】

Yvonne — Sun, 05 Dec 2010 07:34:34 +0000

上周开始可以开始参与需求工作了，暂时参与需求跟踪和需求分析两个方面，先谈谈对需求分析的认识（太教科书的东西自己已经看了很多，不再这儿赘述）：

最初的想法：需求来源于客户，所以我们尽量采集客户的需求，然后整合规划后按照客户的希望实现即可。

实际情况：假设客户可以正确的表达自己的want和need，但究竟想要个怎样的产品来满足自己的want和need客户通常没想好，或者压根儿不愿意想。这个设计、实现产品的工作就需要我们来做。我们要制造需求，并培养需求。

对新需求的需求分析是从想法到产品的分析，重点在思考如何实现；
新需求实现后如果需要整合到整个产品中，就要重点分析对原有功能的影响：

并入需求和整个产品的风格是否一致？
新需求属于整个产品框架的哪部分？
业务流程是否有矛盾？
功能是否有冗余？
加入新功能后是否可提升产品的整体功能和竞争力？
新需求的数据来源于哪里？处理后流向何处？

暂时想到这些，多问些问题还是有好处的，提问有助于促进思考。

shell脚本小技巧总结【继续更新】

admin — Thu, 02 Dec 2010 14:13:00 +0000

今天写了个shell脚本，发现之前学的有关shell脚本的内容长时间不用，基本上是忘没了，所有的内容都

必须从网上现找，如判断文件是否存在等，今天就记录下学到的有关shell脚本的内容，后续有关内容也要

继续更新这篇文章的

1，判断文件是否存在

-f 判断文件是否存在

  if [ ! -f $image_file ] ;then
 qemu-img create -b $(pwd)/images/ubuntu-base.img -f qcow2 $image_file
elif [  ... ] ;  then
......
  fi

类似命令还有-x 判断文件是否有执行权限，-d 判断是否是路径，-eq 判断值是否相等，=直接判断是否
字符串相等
2，for loop range 的用法

C CODE

for i in $(<strong>seq 1 10strong>) ; do
image_file="./images/ubuntu-${1}.img"
ps aux | grep $image_file | grep -v grep | awk '{print $2}' | xargs sudo kill -9
done

主要是利用seq命令来实现

3,从ps 命令中提取指定名字的进程号，并将其killl掉

 ps aux | grep $image_file | grep -v grep | awk '{print $2}' | xargs sudo kill -9
 #$image_file 为进程的名字

4, shell进行算术运算
1> expr

i=7
j =8
c=`expr $i + $j`

2> let

i=7
j =8
let c=i+j

3> (())

i=7
j =8
$((c=i+j))

4> bc

echo "scale=2; 0.5 * 0.5" | bc

echo "0.5*0.5" | bc -l

未完待续

一个对MapReduce理解绝佳的例子

admin — Thu, 02 Dec 2010 11:53:43 +0000

MapReduce编程模式可以简单归纳为这个Unix Shell：

cat input|grep xxx|sort|uniq -c|cat > output

对应典型MapReduce的几个阶段：

Input|Map|Shuffle & Sort|Reduce|Output

gdb交叉编译的方法

admin — Thu, 02 Dec 2010 09:26:27 +0000

最近需要在32位机器上调试64位的内核，需要在32位机器上编译出能够读取64位的内核文件vmlinux的gdb，今天问周老师，原来gdb本身可以支持交叉编译，gdb好强悍！！

正确的编译方法：

./configure --target=x86_64-linux-gnu

错误方法：

./configure --target=x86_64

*** BFD does not support target x86_64-pc-none.
*** Look in bfd/config.bfd for supported targets.
make[1]: *** [configure-bfd] Error 1
make[1]: Leaving directory `/home/yaronli/software-tar/gdb-6.8'
make: *** [all] Error 2

我刚开始用得这个选项，一直报错

linux下x86架构下的内联汇编用法

admin — Tue, 30 Nov 2010 09:10:58 +0000

如果您是 Linux 内核的开发人员，您会发现自己经常要对与体系结构高度相关的功能进行编码或优化代码路径。您很可能是通过将汇编语言指令插入到 C 语句的中间（又称为内联汇编的一种方法）来执行这些任务的。让我们看一下 Linux 中内联汇编的特定用法。（我们将讨论限制在 IA32 汇编。）

GNU 汇编程序简述

让我们首先看一下 Linux 中使用的基本汇编程序语法。GCC（用于 Linux 的 GNU C 编译器）使用 AT&T 汇编语法。下面列出了这种语法的一些基本规则。（该列表肯定不完整；只包括了与内联汇编相关的那些规则。）

寄存器命名
寄存器名称有 % 前缀。即，如果必须使用 eax，它应该用作 %eax。

源操作数和目的操作数的顺序
在所有指令中，先是源操作数，然后才是目的操作数。这与将源操作数放在目的操作数之后的 Intel 语法不同。

mov %eax, %ebx, transfers the contents of eax to ebx.

操作数大小
根据操作数是字节 (byte)、字 (word) 还是长型 (long)，指令的后缀可以是 b、w 或 l。这并不是强制性的；GCC 会尝试通过读取操作数来提供相应的后缀。但手工指定后缀可以改善代码的可读性，并可以消除编译器猜测不正确的可能性。

movb %al, %bl -- Byte move
    movw %ax, %bx -- Word move
    movl %eax, %ebx -- Longword move

立即操作数
通过使用 $ 指定直接操作数。

movl $0xffff, %eax -- will move the value of 0xffff into eax register.

间接内存引用
任何对内存的间接引用都是通过使用 ( ) 来完成的。

movb (%esi), %al -- will transfer the byte in the memory
 pointed by esi into al
register

内联汇编

GCC 为内联汇编提供特殊结构，它具有以下格式：

GCG 的 “asm” 结构

   asm ( assembler template

: output operands               (optional)

: input operands                (optional)

: list of clobbered registers
    (optional)

);

本例中，汇编程序模板由汇编指令组成。输入操作数是充当指令输入操作数使用的 C 表达式。输出操作数是将对其执行汇编指令输出的 C 表达式。

内联汇编的重要性体现在它能够灵活操作，而且可以使其输出通过 C 变量显示出来。因为它具有这种能力，所以 “asm” 可以用作汇编指令和包含它的 C 程序之间的接口。

一个非常基本但很重要的区别在于 简单内联汇编只包括指令，而 扩展内联汇编包括操作数。要说明这一点，考虑以下示例：

内联汇编的基本要素

{
    int a=10, b;
    asm ("movl %1, %%eax;

movl %%eax, %0;"
        :"=r"(b)  /* output */
        :"r"(a)       /* input */
        :"%eax"); /* clobbered register */
}

在上例中，我们使用汇编指令使 “b” 的值等于 “a”。请注意以下几点：

“b” 是输出操作数，由 %0 引用，”a” 是输入操作数，由 %1 引用。
“r” 是操作数的约束，它指定将变量 “a” 和 “b” 存储在寄存器中。请注意，输出操作数约束应该带有一个约束修饰符 “=”，指定它是输出操作数。
要在 “asm” 内使用寄存器 %eax，%eax 的前面应该再加一个 %，换句话说就是 %%eax，因为 “asm” 使用 %0、%1 等来标识变量。任何带有一个 % 的数都看作是输入／输出操作数，而不认为是寄存器。
第三个冒号后的修饰寄存器 %eax 告诉将在 “asm” 中修改 GCC %eax 的值，这样 GCC 就不使用该寄存器存储任何其它的值。
movl %1, %%eax 将 “a” 的值移到 %eax 中， movl %%eax, %0 将 %eax 的内容移到 “b” 中。
因为 “b” 被指定成输出操作数，因此当 “asm” 的执行完成后，它将反映出更新的值。换句话说，对 “asm” 内 “b” 所做的更改将在 “asm” 外反映出来。

现在让我们更详细的了解每一项的含义。

汇编程序模板

汇编程序模板是一组插入到 C 程序中的汇编指令（可以是单个指令，也可以是一组指令）。每条指令都应该由双引号括起，或者整组指令应该由双引号括起。每条指令还应该用一个定界符结尾。有效的定界符为新行 (\n) 和分号 (;)。 ‘\n’ 后可以跟一个 tab(\t) 作为格式化符号，增加 GCC 在汇编文件中生成的指令的可读性。指令通过数 %0、%1 等来引用 C 表达式（指定为操作数）。

如果希望确保编译器不会在 “asm” 内部优化指令，可以在 “asm” 后使用关键字 “volatile”。如果程序必须与 ANSI C 兼容，则应该使用 __asm__ 和 __volatile__，而不是 asm 和 volatile。

操作数

C 表达式用作 “asm” 内的汇编指令操作数。在汇编指令通过对 C 程序的 C 表达式进行操作来执行有意义的作业的情况下，操作数是内联汇编的主要特性。

每个操作数都由操作数约束字符串指定，后面跟用括弧括起的 C 表达式，例如：”constraint” (C expression)。操作数约束的主要功能是确定操作数的寻址方式。

可以在输入和输出部分中同时使用多个操作数。每个操作数由逗号分隔开。

在汇编程序模板内部，操作数由数字引用。如果总共有 n 个操作数（包括输入和输出），那么第一个输出操作数的编号为 0，逐项递增，最后那个输入操作数的编号为 n -1。总操作数的数目限制在 10，如果机器描述中任何指令模式中的最大操作数数目大于 10，则使用后者作为限制。

修饰寄存器列表

如果 “asm” 中的指令指的是硬件寄存器，可以告诉 GCC 我们将自己使用和修改它们。这样，GCC 就不会假设它装入到这些寄存器中的值是有效值。通常不需要将输入和输出寄存器列为 clobbered，因为 GCC 知道 “asm” 使用它们（因为它们被明确指定为约束）。不过，如果指令使用任何其它的寄存器，无论是明确的还是隐含的（寄存器不在输入约束列表中出现，也不在输出约束列表中出现），寄存器都必须被指定为修饰列表。修饰寄存器列在第三个冒号之后，其名称被指定为字符串。

至于关键字，如果指令以某些不可预知且不明确的方式修改了内存，则可能将 “memory” 关键字添加到修饰寄存器列表中。这样就告诉 GCC 不要在不同指令之间将内存值高速缓存在寄存器中。

操作数约束

前面提到过，”asm” 中的每个操作数都应该由操作数约束字符串描述，后面跟用括弧括起的 C 表达式。操作数约束主要是确定指令中操作数的寻址方式。约束也可以指定：

是否允许操作数位于寄存器中，以及它可以包括在哪些种类的寄存器中
操作数是否可以是内存引用，以及在这种情况下使用哪些种类的地址
操作数是否可以是立即数

约束还要求两个操作数匹配。

常用约束

在可用的操作数约束中，只有一小部分是常用的；下面列出了这些约束以及简要描述。有关操作数约束的完整列表，请参考 GCC 和 GAS 手册。

寄存器操作数约束 (r)
使用这种约束指定操作数时，它们存储在通用寄存器中。请看下例：

asm ("movl %%cr3, %0\n" :"=r"(cr3val));

这里，变量 cr3val 保存在寄存器中，%cr3 的值复制到寄存器上，cr3val 的值从该寄存器更新到内存中。指定 “r” 约束时，GCC 可以将变量 cr3val 保存在任何可用的 GPR 中。要指定寄存器，必须通过使用特定的寄存器约束直接指定寄存器名。

a   %eax
b   %ebx
c   %ecx
d   %edx
S   %esi
D   %edi

内存操作数约束 (m)
当操作数位于内存中时，任何对它们执行的操作都将在内存位置中直接发生，这与寄存器约束正好相反，后者先将值存储在要修改的寄存器中，然后将它写回内存位置中。但寄存器约束通常只在对于指令来说它们是绝对必需的，或者它们可以大大提高进程速度时使用。当需要在 “asm” 内部更新 C 变量，而您又确实不希望使用寄存器来保存其值时，使用内存约束最为有效。例如，idtr 的值存储在内存位置 loc 中：

 ("sidt %0\n" : :"m"(loc));

匹配（数字）约束
在某些情况下，一个变量既要充当输入操作数，也要充当输出操作数。可以通过使用匹配约束在 “asm” 中指定这种情况。

asm ("incl %0" :"=a"(var):"0"(var));

在匹配约束的示例中，寄存器 %eax 既用作输入变量，也用作输出变量。将 var 输入读取到 %eax，增加后将更新的 %eax 再次存储在 var 中。这里的 “0″ 指定第 0 个输出变量相同的约束。即，它指定 var 的输出实例只应该存储在 %eax 中。该约束可以用于以下情况：

输入从变量中读取，或者变量被修改后，修改写回到同一变量中
不需要将输入操作数和输出操作数的实例分开

使用匹配约束最重要的意义在于它们可以导致有效地使用可用寄存器。

一般内联汇编用法示例

以下示例通过各种不同的操作数约束说明了用法。有如此多的约束以至于无法将它们一一列出，这里只列出了最经常使用的那些约束类型。

“asm” 和寄存器约束 “r” 让我们先看一下使用寄存器约束 r 的 “asm”。我们的示例显示了 GCC 如何分配寄存器，以及它如何更新输出变量的值。

int main(void)
{
    int x = 10, y;

    asm ("movl %1, %%eax;

 "movl %%eax, %0;"
        :"=r"(y)  /* y is output operand */
        :"r"(x)       /* x is input operand */
        :"%eax"); /* %eax is clobbered register */
}

在该例中，x 的值复制为 “asm” 中的 y。x 和 y 都通过存储在寄存器中传递给 “asm”。为该例生成的汇编代码如下：

main:
pushl %ebp
movl %esp,%ebp
subl $8,%esp
movl $10,-4(%ebp)
movl -4(%ebp),%edx  /* x=10 is stored in %edx */
#APP    /* asm starts here */
movl %edx, %eax     /* x is moved to %eax */
movl %eax, %edx     /* y is allocated in edx and updated */
#NO_APP /* asm ends here */
movl %edx,-8(%ebp)  /* value of y in stack is updated with 

 the value in %edx */

当使用 “r” 约束时，GCC 在这里可以自由分配任何寄存器。在我们的示例中，它选择 %edx 来存储 x。在读取了 %edx 中 x 的值后，它为 y 也分配了相同的寄存器。

因为 y 是在输出操作数部分中指定的，所以 %edx 中更新的值存储在 -8(%ebp)，堆栈上 y 的位置中。如果 y 是在输入部分中指定的，那么即使它在 y 的临时寄存器存储值 (%edx) 中被更新，堆栈上 y 的值也不会更新。

因为 %eax 是在修饰列表中指定的，GCC 不在任何其它地方使用它来存储数据。

输入 x 和输出 y 都分配在同一个 %edx 寄存器中，假设输入在输出产生之前被消耗。请注意，如果您有许多指令，就不是这种情况了。要确保输入和输出分配到不同的寄存器中，可以指定 & 约束修饰符。下面是添加了约束修饰符的示例。

int main(void)
{
    int x = 10, y;

    asm ("movl %1, %%eax;

 "movl %%eax, %0;"
        :"=&r"(y) /* y is output operand, note the    

 & constraint modifier. */
        :"r"(x)       /* x is input operand */
        :"%eax"); /* %eax is clobbered register */
}

以下是为该示例生成的汇编代码，从中可以明显地看出 x 和 y 存储在 “asm” 中不同的寄存器中。

main:
pushl %ebp
movl %esp,%ebp
subl $8,%esp
movl $10,-4(%ebp)
movl -4(%ebp),%ecx  /* x, the input is in %ecx */
#APP
    movl %ecx, %eax
    movl %eax, %edx     /* y, the output is in %edx */
#NO_APP
movl %edx,-8(%ebp)

特定寄存器约束的使用

现在让我们看一下如何将个别寄存器作为操作数的约束指定。在下面的示例中，cpuid 指令采用 %eax 寄存器中的输入，然后在四个寄存器中给出输出：%eax、%ebx、%ecx、%edx。对 cpuid 的输入（变量 “op”）传递到 “asm” 的 eax 寄存器中，因为 cpuid 希望它这样做。在输出中使用 a、b、c 和 d 约束，分别收集四个寄存器中的值。

asm ("cpuid"
: "=a" (_eax),
"=b" (_ebx),
"=c" (_ecx),
"=d" (_edx)
: "a" (op));

在下面可以看到为它生成的汇编代码（假设 _eax、_ebx 等… 变量都存储在堆栈上）：

movl -20(%ebp),%eax /* store 'op' in %eax -- input */
#APP
cpuid
#NO_APP
movl %eax,-4(%ebp)  /* store %eax in _eax -- output */
movl %ebx,-8(%ebp)  /* store other registers in
movl %ecx,-12(%ebp)
 respective output variables */
movl %edx,-16(%ebp)

strcpy 函数可以通过以下方式使用 “S” 和 “D” 约束来实现：

asm ("cld\n

rep\n

movsb"

: /* no input */

:"S"(src), "D"(dst), "c"(count));

通过使用 “S” 约束将源指针 src 放入 %esi 中，使用 “D” 约束将目的指针 dst 放入 %edi 中。因为 rep 前缀需要 count 值，所以将它放入 %ecx 中。

在下面可以看到另一个约束，它使用两个寄存器 %eax 和 %edx 将两个 32 位的值合并在一起，然后生成一个64 位的值：

#define rdtscll(val) \
 __asm__ __volatile__ ("rdtsc" : "=A" (val))
The generated assembly looks like this (if val has a 64 bit memory space).
#APP
rdtsc
#NO_APP
movl %eax,-8(%ebp)  /* As a result of A constraint
movl %edx,-4(%ebp)
 %eax and %edx serve as outputs */
Note here that the values in %edx:%eax serve as 64 bit output.

使用匹配约束

在下面将看到系统调用的代码，它有四个参数：

#define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4) \
type name (type1 arg1, type2 arg2, type3 arg3, type4 arg4) \
{ \
long __res; \
__asm__ volatile ("int $0x80" \
: "=a" (__res) \
: "0" (__NR_##name),"b" ((long)(arg1)),"c" ((long)(arg2)), \
"d" ((long)(arg3)),"S" ((long)(arg4))); \
__syscall_return(type,__res); \
}

在上例中，通过使用 b、c、d 和 S 约束将系统调用的四个自变量放入 %ebx、%ecx、%edx 和 %esi 中。请注意，在输出中使用了 “=a” 约束，这样，位于 %eax 中的系统调用的返回值就被放入变量 __res 中。通过将匹配约束 “0″ 用作输入部分中第一个操作数约束，syscall 号 __NR_##name 被放入 %eax 中，并用作对系统调用的输入。这样，这里的 %eax 既可以用作输入寄存器，又可以用作输出寄存器。没有其它寄存器用于这个目的。另请注意，输入（syscall 号）在产生输出（syscall 的返回值）之前被消耗（使用）。

内存操作数约束的使用

请考虑下面的原子递减操作：

__asm__ __volatile__(
"lock; decl %0"
:"=m" (counter)
:"m" (counter));

为它生成的汇编类似于：

#APP
    lock
    decl -24(%ebp) /* counter is modified on its memory location */
#NO_APP.

您可能考虑在这里为 counter 使用寄存器约束。如果这样做，counter 的值必须先复制到寄存器，递减，然后对其内存更新。但这样您会无法理解锁定和原子性的全部意图，这些明确显示了使用内存约束的必要性。

使用修饰寄存器

请考虑内存拷贝的基本实现。

   asm ("movl $count, %%ecx;

up: lodsl;  

stosl;

loop up;"
        :           /* no output */
        :"S"(src), "D"(dst) /* input */
        :"%ecx", "%eax" );  /* clobbered list */

当 lodsl 修改 %eax 时，lodsl 和 stosl 指令隐含地使用它。%ecx 寄存器明确装入 count。但 GCC 在我们通知它以前是不知道这些的，我们是通过将 %eax 和 %ecx 包括在修饰寄存器集中来通知 GCC 的。在完成这一步之前，GCC 假设 %eax 和 %ecx 是自由的，它可能决定将它们用作存储其它的数据。请注意，%esi 和 %edi 由 “asm” 使用，它们不在修饰列表中。这是因为已经声明 “asm” 将在输入操作数列表中使用它们。这里最低限度是，如果在 “asm” 内部使用寄存器（无论是明确还是隐含地），既不出现在输入操作数列表中，也不出现在输出操作数列表中，必须将它列为修饰寄存器。

原文地址：http://www.ibm.com/developerworks/cn/linux/sdk/assemble/inline/index.html#main

soso 和 sogou 网页player循环方式提示对比

Yvonne — Tue, 30 Nov 2010 05:54:28 +0000

soso player:

sogou player:

soso player 比 sogou player 多了一个顺序循环的方式，应该是顺序播放列表中的内容，最后一个播完后停止。sogou player 没有此功能，但从我的角度出发，一点儿都不介意这个功能，如果可以顺序播放一个列表中的内容，播放完是否重新播放第一个都无所谓，甚至列表循环和顺序两者我更喜欢列表循环的方式。

sogou的循环方式用小图标全部显示在页面中，且设计上通俗易懂，并且辅助悬浮Tooltips提示，比较喜欢。

康神之网站那些事

admin — Thu, 25 Nov 2010 05:17:22 +0000

程序员眼中的编程语言

admin — Mon, 22 Nov 2010 02:28:40 +0000

下图是一个搞笑的图片——程序员眼中的编程语言。

图片的横轴是编程语言。
纵轴是各语言的程序员、粉丝、信徒。
中间的各个小图片则是，粉丝眼中的编程语言的形象。

比如说，

第一行第一列，是Java程序员看Java语言的样子，一幢现代化的大厦。
第一行第二列，是Java程序员看C语言，一个年老过时的骨灰级老头。
当然，C程序员看Java语言也比较搞，见第二行第一列。呵呵。

其它的大家自己看吧。还有另外一个关于操作系统的《粉丝眼中的操作系统》

poj3691分析与解题报告

admin — Sun, 21 Nov 2010 14:16:06 +0000

题目链接：http://poj.org/problemstatus?problem_id=3691

题目大意

给定一系列代表疾病的DNA序列，同时已知一条DNA序列，计算改变最少的DNA序列来使这个DNA序列不包含疾病的DNA序列

例如：

AAA
AAG
#前面两列代表疾病的DNA序列

AAAG #正常的DNA序列

输出：1     #修改第三个字符即可

解题思路

AC自动机+状态dp
首先由desease的DNA序列，构造出Trie树即AC自动机，也可以叫做DFA图，每个节点代表一种状态，然后利用状态转移的动态规划方法，dp[i][j] 表示到目标串的第 i 个字符，DFA 状态为 j 时的最小修改数量，具体方程分为两种，已知dp[i-1][j]：
1，child[sequence[i]] 状态j的匹配第i个字符的子节点 && !is_danger
dp[i][child[sequence[i]]] = min{dp[i][child[sequence[j]]], dp[i-1][j]}
2，状态j的其他子节点 && is_danger
dp[i][other_child] = min{dp[i][other_child], dp[i-1][other_child] + 1}

最后在所有的dp[len-1][j] &&!is_danger 中找到最小的值极为所求

C CODE

/*
 * Author: liyangguang 
 * http://www.yaronspace.cn/blog
 *
 * File: 3691.cc
 * Create Date: 2010-11-14 20:34:41
 *
 */
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#define MAX_STR_LEN 1001
#define MAX_NODES 800
using namespace std;
struct TrieNode {
    TrieNode *next[4];     
    TrieNode *fail;
    // 是否是边界
    int isdanger;
    int index;
    TrieNode():fail(0),isdanger(0),index(0)
    {
        memset(next, 0, sizeof(next));
    }
};
class TrieTree
{
    public:
        TrieNode *root;
        vector<TrieNode *> node_list;
        TrieTree():root(0) { Init();}
        void Init();
        void Insert(const string& str);
        // 构造fail指针
        void BuildTrieTree();
        virtual ~TrieTree();
 
};
inline int id(char ch)
{
    switch (ch) {
        case 'A':return 0;
        case 'T':return 1;
        case 'G':return 2;
        case 'C':return 3;
    }
}
void
TrieTree::Init()
{
    root = new TrieNode();
    root->index = 0;
    node_list.push_back(root);
}
void
TrieTree::Insert(const string& str)
{
    int size = str.size();
    TrieNode *r = root;
    int i = 0, j = 0;
    for (j = 0; j < size; ++j) {
        i = id(str[j]);
        if (r->next[i] == NULL) {
            r->next[i] = new TrieNode();
            r->next[i]->index = node_list.size();
            node_list.push_back(r->next[i]);
        }
        r = r->next[i];
    }
    r->isdanger = 1;
}
void 
TrieTree::BuildTrieTree()
{
    TrieNode* r = root, *p;
    queue<TrieNode *> q;
    root->fail = root;
    q.push(root);
    int i = 0;
    while (!q.empty()) {
        p = q.front();
        q.pop();
        p->isdanger = p->isdanger || p->fail->isdanger;
        for (i = 0; i < 4; ++i) {
            if (p->next[i] == NULL) {
                p->next[i] = (p == root) ? root : p->fail->next[i];
            }
            else
            {
                p->next[i]->fail = (p == root) ? root : p->fail->next[i];
                q.push(p->next[i]);
            }
        }
 
    }
}
 
TrieTree::~TrieTree()
{
    vector<TrieNode *>::iterator itr;
    itr = node_list.begin();
    for(; itr != node_list.end();++itr) {
        delete *itr;
    }
    node_list.clear();
}
void 
checkmin(int& a,int b) {
    if(a==-1) a=b;
    else if(a>b) a=b;
}
//记录状态方程的信息
int dp[MAX_STR_LEN][MAX_NODES] = {0};
int
build_dp(const string &sequences, TrieTree *tree) 
{
    unsigned int i, j, k;
    memset(dp, -1, sizeof(dp));
    if (!tree->node_list[0]->next[id(sequences[0])]->isdanger) {
        dp[0][tree->node_list[0]->next[id(sequences[0])]->index] = 0;
    }
    for (i = 0;i < 4; ++i) {
        if (i != id(sequences[0]) && !tree->node_list[0]->next[i]->isdanger) {
            dp[0][tree->node_list[0]->next[i]->index] = 1;
        }
    }
    for (i = 1;i < sequences.size(); ++i) {
        for (j = 0;j < tree->node_list.size(); ++j) {
            if (dp[i-1][j] != -1)
            {
                if (!tree->node_list[j]->next[id(sequences[i])]->isdanger) {
                    checkmin(dp[i][tree->node_list[j]->next[id(sequences[i])]->index], dp[i-1][j]); 
                }
                for (k = 0; k < 4; ++k) {
                    if (k != id(sequences[i]) && !tree->node_list[j]->next[k]->isdanger) {
                        checkmin(dp[i][tree->node_list[j]->next[k]->index], dp[i-1][j]+1);
                    }
                }
            }
 
        }
    }
    int ans = 1<<20;
    for (i = 0;i < tree->node_list.size();++i) {
        if (!tree->node_list[i]->isdanger && dp[sequences.size() - 1][i] != -1&& dp[sequences.size() - 1][i] < ans)
            ans = dp[sequences.size() - 1][i];
    }
    return ans == 1<<20 ? -1 : ans; 
}
int 
main(int argc, char* argv[])
{
    int cases = 1, n = -1, i = 0;
    string disease, seq;
    while (cin >>n && n != 0) {
        TrieTree *tree = new TrieTree();
        for (i = 0;i < n; ++i) {
            cin >>disease;
            tree->Insert(disease);
        }
        tree->BuildTrieTree();
        cin >> seq;
        printf("Case %d: %d\n",cases++, build_dp(seq, tree));
        delete tree;
    }
    return 0;
}
 
/* vim: set ts=4 sw=4: */

gdb调试程序之查看运行时数据【五】

admin — Sat, 20 Nov 2010 09:44:50 +0000

在用gdb调试程序时，当程序运行到之前设置的断点时，很容易想到的操作就是查看当前变量的值，而gdb可以很轻易地满足的你的需求的~~

在gdb中最常用的命令就是print(简写p)，具体格式如下：

print 
print/f   f代表输出的格式
 x 按十六进制格式显示变量
 d 按十进制格式显示变量
 u 按十六进制格式显示无符号整型
 o 按八进制格式显示变量
 t 按二进制格式显示变量
 a 按十六进制格式显示变量
 c 按字符格式显示变量
 f 按浮点数格式显示变量

表达式

print命令可以接受表达式，其中表达式的定义遵循C/C++语法，需要注意的是表达式中不能出现程序中定义的宏表达式；同时在gdb表达式中，还支持以下三种特殊的操作符：

@       是一个和数组有关的操作符，在后面会有更详细的说明
::      指定一个在文件或是一个函数中的变量，注意与C++语法中的::操作符的区分
{}      表示一个指向内存地址的类型为type的一个对象

程序变量的定位

在GDB中，查看以下三种变量的值：
1、全局变量（所有文件可见的）
2、静态全局变量（当前文件可见的）
3、局部变量（当前Scope可见的）

如果出现局部变量和全局变量相互冲突时，局部变量会覆盖全局变量，可以使用::限制符来查看全局变量

file::variable
function::variable

注意事项：如果在编译时加入了编译优化选项，即-O3选项，编译器会修改你的程序，同时可能查看不同某些变量，这时在调试时建议把优化选项关掉，即-O0

动态数组

你需要查看一段连续的内存空间的值。比如数组的一段，或是动态分配的数据的大小。你可以使用GDB的“@”操作符，“@”的左边是第一个内存的地址的值，“@”的右边则你你想查看内存的长度。例如，你的程序中有这样的语句：

int *array = (int *) malloc (len * sizeof (int));

于是，在GDB调试过程中，你可以以如下命令显示出这个动态数组的取值：

p *array@len

@的左边是数组的首地址的值，也就是变量array所指向的内容，右边则是数据的长度，其保存在变量len中，其输出结果，大约是下面这个样子的：

(gdb) p *array@len
$1 = {2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40}

查看内存

gdb中可以使用examine命令来查看内存内容，简写为x，使用方法如下：

x/ 
  n、f、u是可选的参数。
  n 是一个正整数，表示显示内存的长度，也就是说从当前地址向后显示几个地址的内容。
  f 表示显示的格式，参见上面。如果地址所指的是字符串，那么格式可以是s，如果地十是指令地址，那么格式可以是i。
  u 表示从当前地址往后请求的字节数，如果不指定的话，GDB默认是4个bytes。u参数可以用下面的字符来代替，b表示单字节，h表示双字节，w表示四字节，g表示八字节。
    当我们指定了字节长度后，GDB会从指内存定的内存地址开始，读写指定字节，并把其当作一个值取出来。
  表示一个内存地址。

例如

x/3uh 0x54320  从内存地址0x54320读取内容，h表示以双字节为一个单位，3表示三个单位，u表示按十六进制显示

自动显示

在gdb中，你可以设置当程序停在断点处时，自动显示变量的内容，即display命令，使用如下：

 display 
 display/ 
 display/ 
 expr是一个表达式，fmt表示显示的格式，addr表示内存地址

一个非常有用的命令，显示源码与机器码的对应：

display/i $pc
$pc是GDB的环境变量，表示着指令的地址，/i则表示输出格式为机器指令码，也就是汇编。于是当程序停下后，就会出现源代码和机器指令码相对应的情形

与display管理相关的命令：

undisplay
delete display
disable display
enable display
info display  查看display设置的自动显示的信息

查看寄存器

info registers            查看寄存器的情况。（除了浮点寄存器）
info all-registers        查看所有寄存器的情况。（包括浮点寄存器）
info registers       查看所指定的寄存器的情况

gdb调试程序之栈和源码信息【四】

admin — Mon, 15 Nov 2010 12:47:42 +0000

显示栈信息

当程序停在你设置的断点处时，你首先需要看的是函数调用的过程即函数调用栈，及每层栈中函数的名称、参数和局部变量等信息，这时可以用gdb提供的backtrace(bt)来查看函数调用栈信息

backtrace ， bt  n是一个正整数，表示只打印栈顶上n层的栈信息。

backtrace <-n> ，bt <-n> -n表一个负整数，表示只打印栈底下n层的栈信息。

   (gdb) bt
        #0 func (n=250) at tst.c:6
        #1 0x08048524 in main (argc=1, argv=0xbffff674) at tst.c:30
        #2 0x400409ed in __libc_start_main () from /lib/libc.so.6

从上可以看出函数的调用栈信息：__libc_start_main –> main() –> func()

如果你要查看某一层的信息，你需要在切换当前的栈，一般来说，程序停止时，最顶层的栈就是当前栈，如果你要查看栈下面层的详细信息，首先要做的是切换当前栈，此时可以用frame命令来进行切换

frame    是一个从0开始的整数，是栈中的层编号。比如：frame 0，表示栈顶，frame 1，表示栈的第二层。
up          表示向栈的上面移动n层，可以不打n，表示向上移动一层。

down        表示向栈的下面移动n层，可以不打n，表示向下移动一层。

当切换到某个某层frame时，可以使用info命令来查看当前函数的具体信息

info frame  显示当前frame的详细信息
info args    显示函数的参数的详细信息
info locals     打印出当前函数中所有局部变量及其值
info catch      打印出当前的函数中的异常处理信息

显示源代码

GDB 可以打印出所调试程序的源代码，当然，在程序编译时一定要加上-g的参数，把源程序信息编译到执行文件中，具体可以使用list命令来查看源代码程序

list + 参数
一般来说在list后面可以跟以下这们的参数：
   行号。
    <+offset>   当前行号的正偏移量
    <-offset>   当前行号的负偏移量
     哪个文件的哪一行
     函数名
     哪个文件中的哪个函数
    <*address> 程序运行时的语句在内存中的地址

搜索源代码

GDB还提供了源代码搜索的命令：

forward-search ，search         向前面搜索。
reverse-search  全部搜索。

其中是正则表达式，也主一个字符串的匹配模式

用-g编译过后的执行程序中只是包括了源文件的名字，没有路径名。GDB提供了可以让你指定源文件的路径的命令，以便GDB进行搜索。

directory    加一个源文件路径到当前路径的前面
directory                      清除所有的自定义的源文件搜索路径信息
show directories            显示定义了的源文件搜索路径

使用info line命令来查看源代码在内存中的地址

(gdb) info line tst.c:func
        Line 5 of "tst.c" starts at address 0x8048456  and ends at 0x804845d .

disassemble命令可以查看当前程序的机器码即汇编指令

(gdb) disassemble func
        Dump of assembler code for function func:
        0x8048450 :       push   %ebp
        0x8048451 :     mov    %esp,%ebp
        0x8048453 :     sub    $0x18,%esp
        0x8048456 :     movl   $0x0,0xfffffffc(%ebp)
        0x804845d :    movl   $0x1,0xfffffff8(%ebp)
        0x8048464 :    mov    0xfffffff8(%ebp),%eax

下面一篇文章将介绍如何查看运行时的数据

gdb调试程序之单步调试【三】

admin — Mon, 15 Nov 2010 12:18:06 +0000

断点维护

在gdb中，如果觉得设置的断点已经没有用处了，可以使用delete clair disable|enable 对断点进行操作

clear         清除所有的已定义的停止点。

clear ，clear         清除所有设置在函数上的停止点。

clear ，clear         清除所有设置在指定行上的停止点。

delete [breakpoints] [range...]        删除指定的断点，breakpoints为断点号。如果不指定断点号，则表示删除所有的断点。range 表示断点号的范围（如：3-7）。其简写命令为d。

比删除更好的方法是disable停止点，disable了的停止点，GDB不会删除，当你还需要时，enable即可.

disable [breakpoints] [range...]
disable所指定的停止点，breakpoints为停止点号。如果什么都不指定，表示disable所有的停止点。简写命令是dis.

enable [breakpoints] [range...]
enable所指定的停止点，breakpoints为停止点号。

enable [breakpoints] once range...
enable所指定的停止点一次，当程序停止后，该停止点马上被GDB自动disable。

enable [breakpoints] delete range...
enable所指定的停止点一次，当程序停止后，该停止点马上被GDB自动删除。

条件断点维护

在前面一篇文章提到，可以使用b if condition 来设置条件断点，当条件成立时，程序自动停止；

同时我们可以使用condition命令来修改条件（只有break和watch命令支持if，catch目前暂不支持if）；

condition           修改断点号为bnum的停止条件为expression。

condition         清除断点号为bnum的停止条件。
还有一个比较特殊的维护命令ignore，你可以指定程序运行时，忽略停止条件几次。

ignore          表示忽略断点号为bnum的停止条件count次。

为停止点设置运行命令

我们可以使用gdb提供的command 来为停止点处设置运行命令，即当程序运行到断点处时，会自动运行先前使用command来设置的命令，这样很方便来进行自动化调试；

commands [bnum]
... command-list ...
end

为断点号bnum指写一个命令列表。当程序被该断点停住时，gdb会依次运行命令列表中的命令。
例如：

break foo if x>0
commands
printf "x is %d\n",x
continue
end

恢复程序运行和单步调试

当程序运行到断点处时，程序被挺住，这时可以使用continue命令使程序继续运行，next或者step命令进行单步跟踪

continue [ignore-count]
c [ignore-count]
fg [ignore-count]

恢复程序运行，直到程序结束，或是下一个断点到来。ignore-count表示忽略其后的断点次数

step

单步跟踪，如果有函数调用，他会进入该函数。进入函数的前提是，此函数被编译有debug信息，后面可以加count也可以不加，不加表示一条条地执行，加表示执行后面的count条指令，然后再停住

set step-mode，set step-mode on

打开step-mode模式，于是，在进行单步跟踪时，程序不会因为没有debug信息而不停住。这个参数有很利于查看机器码

next

单步运行count 条指令，count默认值为1

finish

运行程序，直到当前函数完成返回。并打印函数返回时的堆栈地址和返回值及参数值等信息。

until

可以运行程序直到退出循环体

stepi 或 si，nexti 或 ni

单步跟踪一条机器指令！一条程序代码有可能由数条机器指令完成，stepi和nexti可以单步执行机器指令

poj2513分析与解题报告

admin — Sun, 14 Nov 2010 11:28:29 +0000

题目大意：

给定一系列sticks,每个木棒的两端都涂有颜色，判断是否能够找到将所有的木棒连接起来的方法，使相互连接的木棒的两端的颜色是相同的？

题目链接：http://poj.org/problem?id=2513

解题思路

知识考查点：1，字典树；2，欧拉路：其中又考察了判断是否为连通图；3，并查集

可以将木棒间的关系抽象为一个无向图，无向图的边即代表一根木棒，节点代表木棒两端的颜色

现在要解决的问题是找到一条路径，遍历图的每条边一次，即欧拉路问题

要存在欧拉路就要满足：

1.该图必须是一个连通图

2.该图每个点的度数要么全为偶数，要么有且仅有两个点的度数为奇数

解决方法

1，给所有的颜色进行编号，同时计算所有颜色节点的度数（在木棒断点出现的次数）；这里我试了两种选择：

1>一种是map进行映射，颜色作为key,

2> 还有就是构建Trie树，判断节点是否出现过

在实际编程过程中，使用map提交时超时，最后只好选择Trie树这种更高效率的查找方法

2，使用并查集来检验图的连通性，关于并查集的概念请google之

3，计算所有节点的度数，然后判断是否满足欧拉路的第二个条件

参考资料

1，关于并查集：http://hi.baidu.com/fandywang_jlu/blog/item/b49e40893ddbb0b00f244485.html

2，关于欧拉路：http://hi.baidu.com/luyade1987/blog/item/f2304d0fd6b4922f6059f3ab.html/cmtid/79f3bcecb3b02a30269791b1

理想服务员

Yvonne — Thu, 11 Nov 2010 12:53:54 +0000

你想想，你小时候的志向是什么？你再看看你现在一天都忙啥呢？

你把理想给丢啦！！

gdb调试程序系统之断点设置【二】

admin — Wed, 10 Nov 2010 03:46:23 +0000

调试程序时，暂停程序运行时首要任务，在gdb中有以下几种暂停方法：断点（BreakPoint）、观察点（WatchPoint）、捕捉点（CatchPoint）、信号（Signals）、线程停止（Thread Stops）

设置断点

break	在进入指定函数时停住。C++中可以使用class::function或function(type,type)格式来指定函数名
break	在指定行号停住
break +offset break -offset	在当前行号的前面或后面的offset行停住。offset为自然数
break filename:linenum	在源文件filename的linenum行处停住
break filename:function	在源文件filename的function函数的入口处停住
break *address	在程序运行的内存地址处停住
break	break命令没有参数时，表示在下一条指令处停住
break … if	…可以是上述的参数，condition表示条件，在条件成立时停住。比如在循环境体中，可以设置break if i=100，表示当i为100时停住程序
info breakpoints [n] info break [n]	查看断点时，可使用info命令，如下所示：（注：n表示断点号）

设置观察点

观察点一般来观察某个表达式（变量也是一种表达式）的值是否有变化了，如果有变化，马上停住程序。我们有下面的几种方法来设置观察点：
watch     为表达式（变量）expr设置一个观察点。一量表达式值有变化时，马上停住程序。
rwatch    当表达式（变量）expr被读时，停住程序。
awatch    当表达式（变量）的值被读或被写时，停住程序。
info watchpoints 列出当前所设置了的所有观察点。

设置捕捉点

catch 和tcatch ，用help catch和help tcatch来看具体用法

信号(Signal)

信号是一种软中断，是一种处理异步事件的方法。一般来说，操作系统都支持许多信号。尤其是UNIX，比较重要应用程序一般都会处理信号。UNIX定义了许多信号，比如SIGINT表示中断字符信号，也就是Ctrl+C的信号，SIGBUS表示硬件故障的信号；SIGCHLD表示子进程状态改变信号；SIGKILL表示终止程序运行的信号，等等。信号量编程是UNIX下非常重要的一种技术。

GDB有能力在你调试程序的时候处理任何一种信号，你可以告诉GDB需要处理哪一种信号。你可以要求GDB收到你所指定的信号时，马上停住正在运行的程序，以供你进行调试。你可以用GDB的handle命令来完成这一功能。

handle
在GDB中定义一个信号处理。信号可以以SIG开头或不以SIG开头，可以用定义一个要处理信号的范围（如：SIGIO-SIGKILL，表示处理从SIGIO信号到SIGKILL的信号，其中包括SIGIO，SIGIOT，SIGKILL三个信号），也可以使用关键字all来标明要处理所有的信号。一旦被调试的程序接收到信号，运行程序马上会被GDB停住，以供调试。其可以是以下几种关键字的一个或多个。

Nostop 当被调试的程序收到信号时，GDB不会停住程序的运行，但会打出消息告诉你收到这种信号。
stop 当被调试的程序收到信号时，GDB会停住你的程序。
print 当被调试的程序收到信号时，GDB会显示出一条信息。
noprint 当被调试的程序收到信号时，GDB不会告诉你收到信号的信息。
pass，noignore 当被调试的程序收到信号时，GDB不处理信号。这表示，GDB会把这个信号交给被调试程序会处理。
nopass，ignore 当被调试的程序收到信号时，GDB不会让被调试程序来处理这个信号。

info signals，info handle 查看有哪些信号在被GDB检测中。

线程(Thread Stop)

如果程序是多线程的话，你可以定义你的断点是否在所有的线程上，或是在某个特定的线程。GDB很容易帮你完成这一工作。

break thread
break thread if …
linespec指定了断点设置在的源程序的行号。threadno指定了线程的ID，注意，这个ID是GDB分配的，你可以通过“info threads”命令来查看正在运行程序中的线程信息。如果你不指定thread 则表示你的断点设在所有线程上面。你还可以为某线程指定断点条件。如：
(gdb) break frik.c:13 thread 28 if bartab > lim

当你的程序被GDB停住时，所有的运行线程都会被停住。这方便你你查看运行程序的总体情况。而在你恢复程序运行时，所有的线程也会被恢复运行。那怕是主进程在被单步调试时。

gdb调试程序系列之启动gdb【一】

admin — Wed, 10 Nov 2010 03:28:52 +0000

首先需要在gcc或者g++编译时加入-g选项，这个程序才能将调试信息加入到执行程序中

其次需要把编译优化选项去掉，加入-O0选项，否则的话编译会修改你的源程序，调试时出现诡异的问题；

启动gdb的方法

1、gdb
program也就是你的执行文件，一般在当然目录下。

2、gdb core
用gdb同时调试一个运行程序和core文件，core是程序非法执行后core dump后产生的文件。

3、gdb
如果你的程序是一个服务程序，那么你可以指定这个服务程序运行时的进程ID。gdb会自动attach上去，并调试他。program应该在PATH环境变量中搜索得到。或者是进入gdb后，通过attach PID命令，将调试进程加入到gdb中

gdb启动时常用开关选项

-symbols 
 -s 
 从指定文件中读取符号表。

-se file
 从指定文件中读取符号表信息，并把他用在可执行文件中。

-core 
 -c 
 调试时core dump的core文件。
 -directory 
 -d 
 加入一个源文件的搜索路径。默认搜索路径是环境变量中PATH所定义的路径

更换blog的模板

admin — Tue, 09 Nov 2010 14:19:29 +0000

今天更换下blog的模板，同时把Wordpress 升级到3.0.1,

总体上这个模板感觉还比较好

下载地址：http://wordpress.org/extend/themes/mystique

字符串匹配AC自动机和矩阵乘法

admin — Sun, 07 Nov 2010 14:29:35 +0000

今天搞了一个poj 2778 ，解决方法是AC自动机(Trie树)和矩阵乘法，对于AC自动机的机制理解还不是很清楚，发现算法能力还是太弱了，对着别人的代码居然看不懂。。。。。

先记录下相关资料

1，http://blog.chinaunix.net/u3/113538/showart_2212716.html

2，http://cool8511.blog.hexun.com/29903963_d.html

3，http://www.matrix67.com/blog/archives/276

4，http://www.cppblog.com/RyanWang/archive/2010/01/13/105559.html

类似题目：poj3691 poj 2513

关于增量模型和迭代模型的区别

Yvonne — Sun, 07 Nov 2010 12:50:27 +0000

迭代模型和增量模型都属于并行开发的软件生命周期模型，但是这两个模型大家往往容易混淆或者不好理解。下面对两个模型的区别和相同之处做一下介绍。

迭代是不能并行的，迭代的并行是指迭代任务，比如从3.1-3.31号是一个迭代计划，该迭代计划需求人员可以分析功能点5-功能点10，设计人员可以做功能点3-功能点7的设计，开发人员可以做功能点2-功能点4的开发，测试人员可以做上个迭代周期发布的代码。迭代的并行是指工作流的并行。
大家看到迭代计划是比较复杂的，因此对项目经理的经验要求很高。

增量模型一般是指具有底层框架和平台的项目，在该稳定的框架和平台上，来开发和增加具体的业务功能。每个增量之间相对独立，各个增量可以并行开发，比如：3.1-31号实现增量1（包含5的功能点），3.20-4.15开发增量2（包含另外的4个功能点）。增量内部是瀑布模型。

两种类型的区别在于迭代是基于IBM的RUP的以架构为核心，用例为驱动，角色职责划分不同，在同一时刻项目内部需求、设计、编码、测试的活动都在发生。迭代适合需求不明确、架构风险大的项目，增量适合需求比较明确，架构比较稳定，而且增量功能的实现基本不影响架构。
还有一个不同就是迭代计划是基于角色的，增量计划是基于任务的。

两种类型的相同之处，每个迭代和增量结束后都有产品发布。

转自 http://blog.csdn.net/li_hualing/archive/2007/03/07/1522988.aspx

虚拟机迁移技术漫谈【两篇不错的文章】

admin — Thu, 04 Nov 2010 09:22:13 +0000

虚拟机的迁移技术，为虚拟机的管理提供更方便的支持，可以在不间断服务的情况下，将虚拟机从host A 迁移到 host B!

虚拟机迁移分为三类：

P2V : 物理机到虚拟机的迁移

V2V: 虚拟机到虚拟机的迁移【这个感觉用户还是最大的】

V2P: 虚拟机到物理机的迁移

这个应该是不错的研究和实践方向。

下面是有关虚拟机的迁移和KVM具体实践的文章，

虚拟机迁移技术漫谈，第 1 部分

KVM 虚拟机在物理主机之间迁移的实现

Linux 虚拟化技术

2010 Linux Journal读者选择奖揭晓[CSDN]

admin — Wed, 03 Nov 2010 08:58:25 +0000

完整的榜单如下（提名奖按名次排序）：

最佳Linux发行版 Ubuntu

提名： PCLinuxOS, Debian, Fedora, Pardus

最佳上网本/受限设备发行版 Ubuntu Netbook Remix

提名：Google Android, MeeGo, Puppy, PclinuxOS LXDE

最佳手机系统 Google Android

提名： MeeGo, Symbian, Maemo, Moblin

最佳桌面环境 GNOME 和 KDE

提名：Xfce, LXDE, Fluxbox

最佳Web浏览器 FireFox

提名： Chrome, Opera, Konqueror, Mozilla Seamonkey

最佳Email客户端 Thunderbird

提名：Gmail Web客户端, Kmail, Evolution, mutt

最佳IM客户端 Pidgin

提名： Skype, Kopete, empathy, amsn

最佳IRC客户端 Pidgin

提名： Xchat, irssi, konversation, Quassel

最佳微博客户端 Gwibber

提名：Choqok, Jaiku, Spaz, Nitwit

最佳办公套件 OpenOffice

提名：Google Docs, KOffice, IBM Lotus Symphony, GNOME Office

最佳独立办公软件 Openoffice.org Writer

提名：AbiWord, OOCalc, Scribus, KWord

最佳图像/设计工具 GIMP

提名：InkScape, Blender, Krita

最佳数码照片管理工具 digiKam

提名：Picasa, F-spot, GwenView, gThumb

最佳音频工具 Audacity

提名：Ardour, LMMS, VLC, Jokosher

最佳音频播放器 Amarok

提名：RythmBox, XMMS, Banshee, SongBird

最佳多媒体(视频)播放器 VLC

提名：Mplayer, SMPlayer, Kaffeine, Totem

最佳书签同步工具 Xmarks

提名：Delicious, Weave, Google Chrome Bookmarks Sync

最佳在线协作工具 Google Docs

提名：Wikis, Google Wave, Zimbra, eGroupware

最佳云存储 Dropbox

提名： Ubuntu one, Amazon S3, ownCloud, SpiderOak

最适合孩子的软件 Tux Paint

提名：GCompris, Scratch, Tux Typing, Tux Math Command

最佳游戏 Frozen Bubble

提名：Doom, Battle for Wesnoth, Tux Racer, Enemy Territory Quake Wars

最佳数据库 MySQL

提名：PostgreSQL, SQLite, Oracle, Firebird

最佳备份方案 rsync

提名：tar, Bacula, Amanda, Simple Linux Backup

最佳虚拟化解决方案 VirtualBox

提名： VMware, KVM, Xen, QEMU

最佳监控工具 Nagios

提名：Zabbix, Zenoss Core, Hyperic, Ganglia

最佳版本控制系统 git

提名：Apache Subversion, cvs, bazzaar,mercurial

最佳编程语言 Python

提名： C++, Java, C, Perl

最佳脚本语言 Python

提名：PHP，bash，Perl，Ruby

最佳IDE Eclipse

提名：KDevelop, NetBeans, QT creator, Vim

最佳开源配置管理工具 Puppet

提名：OpenQRM, Cfengine, Chef, Bcfg2

最佳RIA开发平台 Adobe AIR

提名：JavaFx, Google Gears, OpenLaszlo, Mono Moonlight

最佳包管理工具 apt

提名：synaptic, yum, aptitude, Pisi

最佳开源CMS WordPress

提名：Drupal, Joomla, Alfresco, Plone

最佳Linux支持主机提供商 Godaddy.com

提名：Contegix, Dreamhost, 1&1, Rackspace

最佳Linux笔记本供应商 Dell

提名: 联想, 华硕, 宏碁, EmperorLinux

最佳Linux桌面电脑供应商 Dell

提名：HP, System76, Penguin Computing, ZaReason

最佳Linux服务器供应商 IBM

提名：Dell, HP, SUN, System 76

最佳Linux图书《Linux in Nutshell》

提名：《Running Linux》, 《Linux Bible》, 《Linux for Dummies》, 《Understanding the Linux Kernel》

最佳Linux专栏 Hack and / by Kyle Rankin

提名：Paranoid Penguin by Mick Bauer，Work the Shell by Dave Taylor，At the Forge by Reuven Lerner, diff -u by Zack Brown

最佳视频芯片品牌 NVidia

提名：ATI, Intel, VIA

最佳Linux手机 Nokia N900

提名：HTC Nexus One, Motorola Droid , HTC Droid ,HTC EVO

最佳Linux数码产品 Amazon Kindle

提名：Tom Tom Navigation System，Nokia N810 Tablet ,Sheeva Plug ,Archos

最佳新开源项目 MeeGo

提名：Owncloud, Android, CoffeeSaint, rekonq

最佳新商业软件 Fluendo DVD Player

提名：CodeWeavers CrossOver Office for Linux, Nero Linux ,Zenoss Enterprise, Softmark office Suite

年度产品 Android

提名：KDE, Fluendo DVD Player, zabbix, Pardus

组织过程资产

Yvonne — Tue, 02 Nov 2010 12:57:43 +0000

什么是组织过程资产

组织过程资产指一个学习型组织在项目操作过程中所积累的无形资产。组织过程资产的累积程度是衡量一个项目组织管理体系成熟度的重要指标，项目组织在实践中形成自己独特的过程资产，构成组织的核心竞争力。

组织过程资产的内容

组织过程资产主要包括但不限于以下内容：

项目组织在项目管理过程中指定的各种规章制度、指导方针、规范标准、操作程序、工作流程、行为准则和工具方法等。
项目组织在项目操作过程中所获得的经验和教训，其中既包括已经形成文字的档案，也包括留在团队成员脑子中没有形成文字的思想。
项目组织在项目管理过程中形成的所有文档，包括知识资料库、文档模板、标准化的表格、风险清单等。
项目组织在以往的项目操作过程中留下的历史信息。

组织过程资产的构成

组织过程资产由两类构成：

一、组织指导工作的过程和程序：

组织的标准过程，例如标准，政策（如安全和健康政策），标准产品和项目生命周期，质量方针和程序（如过程审核，目标改进，检查清单，以及应用于组织中的标准化过程定义）
标准化的指导方针，工作结构，提案评价标准，以及工作状况测量标准
模板（如风险模板，工作分解结构模板，项目进度网络图模板）
为了满足项目的特殊要求，组织标准过程中采用的指导方针和标准要作适当的修剪
组织通讯需求（如明确可用的通信技术，被许可的传播媒体，录音记录和安全需要）
项目收尾的指导方针或需求（如最终的项目审计，项目评价，产品确认和认可标准）
财政控制程序（如时间报告，必要的花费和支出复核，会计法规，标准合同规定）
问题和缺陷管理过程定义了问题和缺陷控制、鉴别、处理决定和活动条目跟踪
变更控制过程，包括了修改正式的公司标准，政策，计划，过程（或任何项目文档）。以及批准和生效任何改动时遵循的步骤
风险控制过程，包括风险种类，确定概率及其后果，以及概率和后果的矩阵。
批准和发布工作授权的程序

二、存储和检索信息的组织公用知识库：

过程测量数据库是用来收集和提供测量过程和产品的数据
项目文件（如范围，成本，质量基线，执行情况测量基线，项目日历，项目进度网络图，风险登记，计划应对活动，以及定义风险影响）
历史信息和来自知识库的教训（如项目报告和文档，项目收尾信息和文件，跟以前所有项目选择和执行情况有关的信息，以及风险管理努力的信息）
问题和缺陷管理数据库，包含了问题和缺陷的状态，控制信息，问题和缺陷解决方案和行动结果
结构管理知识数据，包含了对所有正式的公司标准、政策、程序和任何项目文档的释义和基线
财政数据库，包含诸如劳动时间、花费成本、预算和任何项目费用超支的信息

转自 http://wiki.mbalib.com/

十个利用矩阵乘法解决的经典题目[经典]

admin — Sun, 31 Oct 2010 14:31:15 +0000

今天看poj2778题目时，看到这篇文章，写得很不错！

最让我诧异的是，这哥们居然是北大中文系的，居然把算法搞的这么透彻，佩服！

blog地址：http://www.matrix67.com/blog

好像目前还没有这方面题目的总结。这几天连续看到四个问这类题目的人，今天在这里简单写一下。这里我们不介绍其它有关矩阵的知识，只介绍矩阵乘法和相关性质。
不要以为数学中的矩阵也是黑色屏幕上不断变化的绿色字符。在数学中，一个矩阵说穿了就是一个二维数组。一个n行m列的矩阵可以乘以一个m行p列的矩阵，得到的结果是一个n行p列的矩阵，其中的第i行第j列位置上的数等于前一个矩阵第i行上的m个数与后一个矩阵第j列上的m个数对应相乘后所有m个乘积的和。比如，下面的算式表示一个2行2列的矩阵乘以2行3列的矩阵，其结果是一个2行3列的矩阵。其中，结果的那个4等于2*2+0*1：

下面的算式则是一个1 x 3的矩阵乘以3 x 2的矩阵，得到一个1 x 2的矩阵：

矩阵乘法的两个重要性质：一，矩阵乘法不满足交换律；二，矩阵乘法满足结合律。为什么矩阵乘法不满足交换律呢？废话，交换过来后两个矩阵有可能根本不能相乘。为什么它又满足结合律呢？仔细想想你会发现这也是废话。假设你有三个矩阵A、B、C，那么(AB)C和A(BC)的结果的第i行第j列上的数都等于所有A(ik)*B(kl)*C(lj)的和（枚举所有的k和l）。

经典题目1 给定n个点，m个操作，构造O(m+n)的算法输出m个操作后各点的位置。操作有平移、缩放、翻转和旋转
这里的操作是对所有点同时进行的。其中翻转是以坐标轴为对称轴进行翻转（两种情况），旋转则以原点为中心。如果对每个点分别进行模拟，那么m个操作总共耗时 O(mn)。利用矩阵乘法可以在O(m)的时间里把所有操作合并为一个矩阵，然后每个点与该矩阵相乘即可直接得出最终该点的位置，总共耗时O(m+n)。假设初始时某个点的坐标为x和y，下面5个矩阵可以分别对其进行平移、旋转、翻转和旋转操作。预先把所有m个操作所对应的矩阵全部乘起来，再乘以 (x,y,1)，即可一步得出最终点的位置。

经典题目2 给定矩阵A，请快速计算出A^n（n个A相乘）的结果，输出的每个数都mod p。
由于矩阵乘法具有结合律，因此A^4 = A * A * A * A = (A*A) * (A*A) = A^2 * A^2。我们可以得到这样的结论：当n为偶数时，A^n = A^(n/2) * A^(n/2)；当n为奇数时，A^n = A^(n/2) * A^(n/2) * A （其中n/2取整）。这就告诉我们，计算A^n也可以使用二分快速求幂的方法。例如，为了算出A^25的值，我们只需要递归地计算出A^12、A^6、 A^3的值即可。根据这里的一些结果，我们可以在计算过程中不断取模，避免高精度运算。

经典题目3 POJ3233 (感谢rmq)
题目大意：给定矩阵A，求A + A^2 + A^3 + … + A^k的结果（两个矩阵相加就是对应位置分别相加）。输出的数据mod m。k<=10^9。
这道题两次二分，相当经典。首先我们知道，A^i可以二分求出。然后我们需要对整个题目的数据规模k进行二分。比如，当k=6时，有：
A + A^2 + A^3 + A^4 + A^5 + A^6 =(A + A^2 + A^3) + A^3*(A + A^2 + A^3)
应用这个式子后，规模k减小了一半。我们二分求出A^3后再递归地计算A + A^2 + A^3，即可得到原问题的答案。

经典题目4 VOJ1049
题目大意：顺次给出m个置换，反复使用这m个置换对初始序列进行操作，问k次置换后的序列。m<=10, k<2^31。
首先将这m个置换“合并”起来（算出这m个置换的乘积），然后接下来我们需要执行这个置换k/m次（取整，若有余数则剩下几步模拟即可）。注意任意一个置换都可以表示成矩阵的形式。例如，将1 2 3 4置换为3 1 2 4，相当于下面的矩阵乘法：

置换k/m次就相当于在前面乘以k/m个这样的矩阵。我们可以二分计算出该矩阵的k/m次方，再乘以初始序列即可。做出来了别忙着高兴，得意之时就是你灭亡之日，别忘了最后可能还有几个置换需要模拟。

经典题目5 《算法艺术与信息学竞赛》207页（2.1代数方法和模型，[例题5]细菌，版次不同可能页码有偏差）
大家自己去看看吧，书上讲得很详细。解题方法和上一题类似，都是用矩阵来表示操作，然后二分求最终状态。

经典题目6 给定n和p，求第n个Fibonacci数mod p的值，n不超过2^31
根据前面的一些思路，现在我们需要构造一个2 x 2的矩阵，使得它乘以(a,b)得到的结果是(b,a+b)。每多乘一次这个矩阵，这两个数就会多迭代一次。那么，我们把这个2 x 2的矩阵自乘n次，再乘以(0,1)就可以得到第n个Fibonacci数了。不用多想，这个2 x 2的矩阵很容易构造出来：

经典题目7 VOJ1067
我们可以用上面的方法二分求出任何一个线性递推式的第n项，其对应矩阵的构造方法为：在右上角的(n-1)*(n-1)的小矩阵中的主对角线上填1，矩阵第 n行填对应的系数，其它地方都填0。例如，我们可以用下面的矩阵乘法来二分计算f(n) = 4f(n-1) – 3f(n-2) + 2f(n-4)的第k项：

利用矩阵乘法求解线性递推关系的题目我能编出一卡车来。这里给出的例题是系数全为1的情况。

经典题目8 给定一个有向图，问从A点恰好走k步（允许重复经过边）到达B点的方案数mod p的值
把给定的图转为邻接矩阵，即A(i,j)=1当且仅当存在一条边i->j。令C=A*A，那么C(i,j)=ΣA(i,k)*A(k,j)，实际上就等于从点i到点j恰好经过2条边的路径数（枚举k为中转点）。类似地，C*A的第i行第j列就表示从i到j经过3条边的路径数。同理，如果要求经过k步的路径数，我们只需要二分求出A^k即可。

经典题目9 用1 x 2的多米诺骨牌填满M x N的矩形有多少种方案，M<=5，N<2^31，输出答案mod p的结果

我们以M=3为例进行讲解。假设我们把这个矩形横着放在电脑屏幕上，从右往左一列一列地进行填充。其中前n-2列已经填满了，第n-1列参差不齐。现在我们要做的事情是把第n-1列也填满，将状态转移到第n列上去。由于第n-1列的状态不一样（有8种不同的状态），因此我们需要分情况进行讨论。在图中，我把转移前8种不同的状态放在左边，转移后8种不同的状态放在右边，左边的某种状态可以转移到右边的某种状态就在它们之间连一根线。注意为了保证方案不重复，状态转移时我们不允许在第n-1列竖着放一个多米诺骨牌（例如左边第2种状态不能转移到右边第4种状态），否则这将与另一种转移前的状态重复。把这8种状态的转移关系画成一个有向图，那么问题就变成了这样：从状态111出发，恰好经过n步回到这个状态有多少种方案。比如，n=2时有3种方案，111-& gt;011->111、111->110->111和111->000->111，这与用多米诺骨牌覆盖3×2矩形的方案一一对应。这样这个题目就转化为了我们前面的例题8。
后面我写了一份此题的源代码。你可以再次看到位运算的相关应用。

经典题目10 POJ2778
题目大意是，检测所有可能的n位DNA串有多少个DNA串中不含有指定的病毒片段。合法的DNA只能由ACTG四个字符构成。题目将给出10个以内的病毒片段，每个片段长度不超过10。数据规模n<=2 000 000 000。
下面的讲解中我们以ATC,AAA,GGC,CT这四个病毒片段为例，说明怎样像上面的题一样通过构图将问题转化为例题8。我们找出所有病毒片段的前缀，把 n位DNA分为以下7类：以AT结尾、以AA结尾、以GG结尾、以?A结尾、以?G结尾、以?C结尾和以??结尾。其中问号表示“其它情况”，它可以是任一字母，只要这个字母不会让它所在的串成为某个病毒的前缀。显然，这些分类是全集的一个划分（交集为空，并集为全集）。现在，假如我们已经知道了长度为 n-1的各类DNA中符合要求的DNA个数，我们需要求出长度为n时各类DNA的个数。我们可以根据各类型间的转移构造一个边上带权的有向图。例如，从 AT不能转移到AA，从AT转移到??有4种方法（后面加任一字母），从?A转移到AA有1种方案（后面加个A），从?A转移到??有2种方案（后面加G 或C），从GG到??有2种方案（后面加C将构成病毒片段，不合法，只能加A和T）等等。这个图的构造过程类似于用有限状态自动机做串匹配。然后，我们就把这个图转化成矩阵，让这个矩阵自乘n次即可。最后输出的是从??状态到所有其它状态的路径数总和。
题目中的数据规模保证前缀数不超过100，一次矩阵乘法是三方的，一共要乘log(n)次。因此这题总的复杂度是100^3 * log(n)，AC了。

最后给出第9题的代码供大家参考（今天写的，熟悉了一下C++的类和运算符重载）。为了避免大家看代码看着看着就忘了，我把这句话放在前面来说：
Matrix67原创，转贴请注明出处。

#include #define SIZE (1< #define MAX_SIZE 32 using namespace std;


class CMatrix

{

public:

long element[MAX_SIZE][MAX_SIZE];

void setSize(int);

void setModulo(int);

CMatrix operator* (CMatrix);

CMatrix power(int);

private:

int size;

long modulo;

};
void CMatrix::setSize(int a)

{

for (int i=0; i
for (int j=0; j
element[i][j]=0;

size = a;

}
void CMatrix::setModulo(int a)

{

modulo = a;

}
CMatrix CMatrix::operator* (CMatrix param)

{

CMatrix product;

product.setSize(size);

product.setModulo(modulo);

for (int i=0; i
for (int j=0; j
for (int k=0; k
{

product.element[i][j]+=element[i][k]*param.element[k][j];

product.element[i][j]%=modulo;

}
return product;

}
CMatrix CMatrix::power(int exp)

{

CMatrix tmp = (*this) * (*this);

if (exp==1) return *this;

else if (exp & 1) return tmp.power(exp/2) * (*this);

else return tmp.power(exp/2);

}
int main()

{

const int validSet[]={0,3,6,12,15,24,27,30};

long n, m, p;

CMatrix unit;
scanf("%d%d%d", &n, &m, &p);

unit.setSize(SIZE);

for(int i=0; i
for(int j=0; j
if( ((~i)&j) == ((~i)&(SIZE-1)) )

{

bool isValid=false;

for (int k=0; k<8; k++)isValid=isValid||(i&j)==validSet[k];

unit.element[i][j]=isValid;

}

unit.setModulo(p); printf("%d", unit.power(n).element[SIZE-1][SIZE-1] ); return 0; }

Linux 系统内核的调试技巧[zz]

admin — Fri, 29 Oct 2010 08:40:18 +0000

调试是软件开发过程中一个必不可少的环节，在 Linux 内核开发的过程中也不可避免地会面对如何调试内核的问题。但是，Linux 系统的开发者出于保证内核代码正确性的考虑，不愿意在 Linux 内核源代码树中加入一个调试器。他们认为内核中的调试器会误导开发者，从而引入不良的修正[1]。所以对 Linux 内核进行调试一直是个令内核程序员感到棘手的问题，调试工作的艰苦性是内核级的开发区别于用户级开发的一个显著特点。

尽管缺乏一种内置的调试内核的有效方法，但是 Linux 系统在内核发展的过程中也逐渐形成了一些监视内核代码和错误跟踪的技术。同时，许多的补丁程序应运而生，它们为标准内核附加了内核调试的支持。尽管这些补丁有些并不被 Linux 官方组织认可，但他们确实功能完善，十分强大。调试内核问题时，利用这些工具与方法跟踪内核执行情况，并查看其内存和数据结构将是非常有用的。

本文将首先介绍 Linux 内核上的一些内核代码监视和错误跟踪技术，这些调试和跟踪方法因所要求的使用环境和使用方法而各有不同，然后重点介绍三种 Linux 内核的源代码级的调试方法。

1. Linux 系统内核级软件的调试技术

printk() 是调试内核代码时最常用的一种技术。在内核代码中的特定位置加入printk() 调试调用，可以直接把所关心的信息打打印到屏幕上，从而可以观察程序的执行路径和所关心的变量、指针等信息。 Linux 内核调试器（Linux kernel debugger，kdb）是 Linux 内核的补丁，它提供了一种在系统能运行时对内核内存和数据结构进行检查的办法。Oops、KDB在文章掌握 Linux 调试技术有详细介绍，大家可以参考。 Kprobes 提供了一个强行进入任何内核例程，并从中断处理器无干扰地收集信息的接口。使用 Kprobes 可以轻松地收集处理器寄存器和全局数据结构等调试信息，而无需对Linux内核频繁编译和启动，具体使用方法，请参考使用 Kprobes 调试内核。

以上介绍了进行Linux内核调试和跟踪时的常用技术和方法。当然，内核调试与跟踪的方法还不止以上提到的这些。这些调试技术的一个共同的特点在于，他们都不能提供源代码级的有效的内核调试手段，有些只能称之为错误跟踪技术，因此这些方法都只能提供有限的调试能力。下面将介绍三种实用的源代码级的内核调试方法。

原文地址

对需求管理和范围管理的理解

Yvonne — Wed, 27 Oct 2010 07:35:16 +0000

1. 什么是需求管理

需求是指项目接受并生产出的产品和产品构建。需求管理是为确保各方对需求理解一致而进行的管理和控制活动。

2. 需求管理包含哪些方面

1) 制定计划：准备所需的软硬件资源、跟踪矩阵、变更申请等，便于管理需求并保持需求管理工作一致。

2) 各方对需求达成共识：各方干系人对确立的需求进行确认，建立一致。

3) 控制需求变更：项目进行期间当发生需求变更将对整个项目产生影响，如果需要变更，要先提出申请说明变更需求的来源，相关人员综合各方面因素审核是否实施变更。

3. 什么是范围管理

项目范围管理界定了为成功完成项目所需要的一系列过程，确保项目包含且仅包含必须完成的工作。即定义和控制项目内包含什么，不包含什么。

4. 范围管理包含哪些方面

在软件开发项目管理中，范围通常包括产品范围和项目范围。

产品范围：表示产品或服务的特性和功能。如需求、目标、工作产品、交付成果；

项目范围：指为了完成产品范围内规定的特征和功能，所必须完成的工作，如确定干系人、WBS、资源安排、时间分配等；

产品范围是否完成以产品需求作为衡量标准；项目范围的完成以项目管理计划作为衡量标准。二者相结合确保项目在规定的时间内、使用特定的资源、按照约定的质量交付约定好的成果。

5. 范围管理与需求管理的关系

1) 范围管理包括需求管理：范围管理需要清楚的定义项目的具体工作范围和工作内容。

2) 需求管理为范围管理提供依据：在需求开发确定的项目需求基础上确定项目的范围，制定工作内容、项目预算、估算时间和资源；根据需求的级别安排资源投入工作；当需求有变更时会引起项目范围和时间的变更，对需求变更的管理可以减小项目管理的风险。

yaronspace.cn 一周年

admin — Wed, 27 Oct 2010 03:13:25 +0000

2009-10-27买了yaronspace.cn域名和空间，纪念下~

再接再厉！！

下面是一年来流量变化情况，数据来自google analytics

yaronli排名还不错

Yvonne — Tue, 26 Oct 2010 07:14:05 +0000

Yaronli 在百度

Yaronli 在google

排名很靠前~~

产品经理能力模型[转]

Yvonne — Tue, 26 Oct 2010 03:25:18 +0000

偶然看到这篇文章，写的很实在，不喜欢理论性太强的，转过来~~

由 Minijuly 撰写 http://www.minijuly.com/?p=830

随着行业发展，产品经理这个群体在IT行业也越来越受到关注，各种产品交流学习组织蓬勃兴起，作为其中的一员，一直以来就想写写自己对于产品经理这一角色的认识。

俗话说，一个成功的男人身后必然有一个默默的女人，那么一款产品背后是否也有一位潜心学习不断专研的产品经理呢？答案是肯定的，而且经常性的还不只是一位产品经理在支持着一款成功的产品。

业内对于产品经理能力模型的归纳也并不鲜见，因此我只是从个人理解的层面去讲述这些能力，我个人主要倾向于把产品经理能力分为两大部分：A、产品能力；B、管理能力。

A、产品能力

一、工具性能力

产品经理对产品负责，相应的产品能力必须是首要的能力，而在这些具体的素质里面，工具性能力又堪称基础性能力，在一个产品策划的生命周期里面，最常见的工具一般有以下几种：word、ppt、mindmanager、visio、axure、excel。

1、Word、excel和ppt，产品经理在策划一款产品的过程中，往往需要同多部门进行沟通协调，于是撰写文档以提高沟通效率便成为一项重要能力，无论是撰写产品需求文档还是市场需求文档、分析后期统计数据都需要熟练使用office系列文件。

2、Mindmanager，作为常用的头脑风暴软件，mindmanager便于产品经理更好的梳理产品管理和逻辑，对于理清产品思路具有重要意义，特别是在绘制产品roadmap其方便快捷的操作可以让产品经理绘制出结构和逻辑性都较好的展示图表。

3、Visio，visio作为一款优秀的流程软件，对于产品经理梳理产品内在逻辑和用户操作流程具有重要意义，特别是在产品文档撰写过程中，visio绘制的用户操作流程图可以帮助工程师更好理解产品逻辑从而实施产品开发。Visio丰富的插件还可以用户绘制ueser case，方便产品项目组人员更好的理解用户，从而指导产品设计。

4、Axure，近年来axure凭借其优秀和交互能力和良好的操作性开始逐渐取代visio用于原型绘制，原型绘制作为产品设计的重要一环使得axure的使用能力也成为产品经理的标配能力之一。

二、产品感

“产品感”，一词来源于前辈郭子威，第一次看到这个词的时候我就眼睛一亮，当时看到的想法就是：bingo，这个词才是我心中产品经理需要的核心能力、一个优秀的产品经理必须对于产品敏感，而这种敏感性就来源于良好的产品感。产品经理是一个综合性角色，即需要有开阔的视野，又必须时刻关注细节，而这些都包含在产品感里面。当然产品感并不是天生的，良好的产品感来源于长期的产品设计积累和对于互联网产品的大量使用。如果你没有“网瘾”，我觉得产品感会变成一个无稽之谈。

a、规划力这是一个产品经理较高层面上的能力，而具备这种能力的产品经理，通常会具备很多思想家的特质。从产品外部体系上，规划力代表了产品经理对整个价值市场的认同，对企业产品线的布局，对自身产品的定位以及对每一款产品的发展思路。当然，对于大部分产品经理而言，战略层面的东西可能还接触不到，特别是对于大型公司，决策层对于战略的考虑会大大多于产品经理，而产品经理在这样的情况下对于战略的执行多于对战略的思考。

b、设计力这里所说的设计能力并不单指对于产品功能和原型的设计，而更大一部分在于是否能够根据公司战略及用户需求找到最好的契合度，规划出即满足公司商业需求又符合市场定位和用户需求的能力。包括产品远景规划和近期的功能规划都属于设计力的范畴。

三、商业感

一个优秀的产品经理必须具有关注整个宏观市场环境的视野和能力，虽然在现实中大部分产品经理依旧在做执行层面的很多问题，对于大环境的关注可能在产品总监或更高领导层面。但是对于一个产品经理的长期成长而言，对于整个大市场环境的关注不但可以使产品经理具有更好的产品视野，也会让产品经理在产品设计的过程中更加敏锐，可以更好的对于产品远景规划作出正确的判断。

B、管理能力

一、自我管理能力

如果用足球比喻产品各个环节的职务角色，产品经理应该是最适合的中场球员，在一场球赛中，中场对于组织进攻，协调防守都具有核心意义。产品经理作为一个协调性角色，对于前方需要协调包括BD、市场、销售在内的各个角色，对于后方又要组织协调好UED、程序等，另外还必须承受来自于用户的指责和质疑，面临的压力可想而知。因此从个人素质上讲一个善于调节情绪，能够自我释放的产品经理才能经的起考验。

二、时间管理能力

产品经理在整个产品生命周期中都扮演者核心角色，并且由于时刻需要针对不同需求去协调不同的部门，产品经理总是最活跃产品角色，既要处理外部问题又要时刻紧盯产品的设计，是否具有良好工作安排协调能力对于产品经理正常完成工作具有重要意义，产品经理最怕跟各部门陷入无休止的扯皮而疲于顾及产品的核心设计工作。

三、知识管理能力

日新月异对于互联网行业来说是最好的形容，如果你不关注市场，关注新技术，说不定某天起床的时候你就会发现自己已经跟不上时代的需求。而良好的学习能力对于产品经理而言将是保持创新活力的基础，面对不断的新技术、新产品产品经理不能目瞪口呆，而应觉得理所当然；其次产品经理本身是综合性角色，对于市场研究、用户调研、产品策划、开发技术、品牌管理、项目管理、心理学、设计科学都必须有所涉猎。只有具有综合的能力，才能立于各部门的沟通中游刃有余。

四、产品管理能力

产品经理必须对整个产品生命周期负责，从前期产品策划中协调各种资源进行开发设计开发，跟进产品上线。到产品上线后的运营推广，产品经理都必须予以关注，以便协调不同的部门安排工作。同事在运营中对于来自各方需求以及市场的新变化都必须时刻关注以便安排产品的迭代更新。产品经理对于一款产品来说就是既当爹又当妈。

五、团队管理能力

1、沟通能力产品经理对于需求的实现都必须依赖技术和UED部门进行，因此良好的无授权领导力成为是否完成工作的主要条件，因此产品经理必须是一个活力角色，只有这样才能调动各部门投入产品设计和开发，从而形成一个核心的产品项目团队，产品经理不能孤军奋战。

2、执行能力产品经理的执行能力不但指个人范围内的工作情况，也包括协调程序、UED部门投入工作的能力，当然这一点又必须依赖于良好的沟通能力。

3、另外产品经理也必须肩负一定的产品团队培养能力，使得产品梯队具有良性的接力效应，从而必须人才青黄不接，导致项目不能正常完成。

systemTap 工具介绍[zz]

admin — Mon, 25 Oct 2010 07:39:26 +0000

SystemTap 是监控和跟踪运行中的 Linux 内核的操作的动态方法。这句话的关键词是动态，因为 SystemTap 没有使用工具构建一个特殊的内核，而是允许您在运行时动态地安装该工具。它通过一个名为Kprobes 的应用编程接口（API）来实现该目的，本文将探索这个 API。我们首先了解以前的一些内核跟踪方法，然后在深入探讨 SystemTap 的架构及其使用。

内核跟踪

SystemTap 与一种名为 DTrace 的老技术相似，该技术源于 Sun Solaris 操作系统。在 DTrace 中，开发人员可以用 D 编程语言（C语言的子集，但修改为支持跟踪行为）编写脚本。DTrace 脚本包含许多探针和相关联的操作，这些操作在探针 “触发” 时发生。例如，探针可以表示简单的系统调用，也可以表示更加复杂的交互，比如执行特定的代码行。清单 1 显示了 DTrace 脚本的一个简单例子，它计算每个进程发出的系统调用的数量（注意，使用字典将计数和进程关联起来）。该脚本的格式包含探针（在发出系统调用时触发）和操作（对应的操作脚本）。

清单 1. 计算每个进程的系统调用的简单 DTrace 脚本

syscall:::entry
{ 

  @num[pid,execname] = count(); 

}

DTrace 是 Solaris 最引人注目的部分，所以在其他操作系统中开发它并不奇怪。DTrace 是在 Common Development and Distribution License (CDDL) 之下发行的，并且被移植到 FreeBSD 操作系统中。

另一个非常有用的内核跟踪工具是 ProbeVue，它是 IBM 为 IBM® AIX® 操作系统 6.1 开发的。您可以使用 ProbeVue 探查系统的行为和性能，以及提供特定进程的详细信息。这个工具使用一个标准的内核以动态的方式进行跟踪。清单 2 显示了 ProbeVue 脚本的一个例子，它指出发出 sync 系统调用的特定进程。

清单 2. 指出哪个进程调用 sync 的简单 ProbeVue 脚本

@@syscall:*:sync:entry
{
  printf( "sync() syscall invoked by process ID %d\n", __pid );
  exit();
}

考虑到 DTrace 和 ProbeVue 在各自的操作系统中的巨大作用，为 Linux 操作系统策划一个实现该功能的开源项目是势不可挡的。SystemTap 从 2005 年开始开发，它提供与 DTrace 和 ProbeVue 类似的功能。许多社区还进一步完善了它，包括 Red Hat、Intel、Hitachi 和 IBM 等。

这些解决方案在功能上都是类似的，在触发探针时使用探针和相关联的操作脚本。现在，我们看一下 SystemTap 的安装，然后探索它的架构和使用。

原文地址

http://www.xmsc.com.cn/InfoView/Article_79967_4.html

主流文本编辑器学习曲线[zz]

admin — Wed, 20 Oct 2010 04:41:42 +0000

有意思

主流编辑器学习曲线图

注1：Pico(PIne COmposer)是Unix操作系统中最常见的三种文字处理软件之一，具有文字编辑、搜索、拼写检查、文件浏览和段对齐功能，适合高效地编辑短小的文件。Pico是由华盛顿大学开发的免费软件，随着pine电子邮件处理软件发布。它是在Emacs的基础上以pine的邮件编辑为目标而开发的，所以其指令集是Emacs的子集，但是由于在界面上有提示快捷键，相对于vi和Emacs来说更加容易使用。由于Pico虽然是免费软件，但是它并不是开源软件，所以很多Linux版本并不包含Pico。这些版本通常提供一个界面类似的开源软件nano——Pico的克隆版。

注2：图中的纵横坐标没有标明。我所理解的是——X轴是熟练程度，Y轴是技能。于是对于notepad 来说，技能和熟练程度呈正比。对于VS来说，熟练程度越大，所需要技能先是越来越多，而随着熟练程度的增长，你需要的技能也越少。而对于VI来说，一开始就需要相当大的技能，但一旦掌握这些技能，则你将会越来越熟练。而对于emacs来说，技能和熟练程度是呈旋涡状。

原文地址：http://coolshell.cn/articles/3125.html

osdi 会议链接

admin — Tue, 19 Oct 2010 14:14:08 +0000

http://www.usenix.org/events/osdi10/tech/

里面有GOOGLE Microsoft 和VMware 等公司的文章，很值得一看，记录下

vim templates模板用法介绍

admin — Mon, 18 Oct 2010 05:31:31 +0000

今天看到一个同学问vim 中新建文件时自动生成如作者、时间等信息的vim 插件，想到之前也试过一些template插件，都没有成功，最后使用doxgen取代之，今天就想试下，google半天终于解决了

下载template.rar 文件，第三方提供

下载地址

1、将文件放入 plugin（~/.vim/plugin/ 或者 $HOME/vimfiles/plugin/）目录

2、.vimrc 加入

let g:template_load = 1

let g:template_tags_replacing = 1

let g:T_AUTHOR = “liyangguang”

let g:T_AUTHOR_EMAIL = “liyangguang@software.ict.ac.cn”

let g:T_AUTHOR_WEBSITE = “http://www.yaronspace.cn/blog”

let g:T_DATE_FORMAT = “%Y-%m-%d %H:%M:%S”

3、新建一个模板文件存为 templates/tpl.c（例如~/.vim/templates/tpl.c）
模板名的取名规则是 tpl.extension，新建*.h的时候，tpl.h 被读入

C CODE

/*
 * Author:  <>
 * 
 *
 * File: 
 * Create Date: 
 *
 */
int 
main(int argc, char* argv[])
{
    return 0;
}
/* vim: set ts=4 sw=4: */

Ok，启动vim，看看是否加载模板成功

ps: 可能会遇到^M是非法字符的错误，使用vim 打开，在命令模式下输入:set ff=unix :w 重启vim即可

yaron's space

gdb调试程序之监控内存【七】

2011年的最后一天

vim使用技巧小结【继续更新】

积攒人品

关于const与volatile笔试题目的分析

分析如下：

关于volatile关键字

linux关于sort命令的高级用法（按多个列值进行排列）

register、volatile、restrict 三关键字的用法[转载]

今天EMC笔试题目

debian系统sshd连接慢的解决办法

linux下多线程编程的几篇不错的博文

查看 CPU, Memory, I/O and NetFlow[转载]

iostat 查看磁盘 I/O

top 查看进程占有率

free 查看内存使用情况

top 查看进程内存使用

获得针对某个 Interface 的网络流量

[编程之美]随机数范围扩展方法总结

问题描述

问题分析

解决方法

归纳总结

参考资料：

推荐firefox插件vimperator (用vim方式使用Firefox)

MySQL索引背后的数据结构及算法原理【好文】

140个Google的面试题【转载】

[编程之美]N个鸡蛋放到M个篮子的方法

题目分析

代码实现

使用mmap实现文件的拷贝

mmap与munmap函数介绍：

实验

源码分析

[编程之美]使用最大堆和最小堆来求中位数

vim中recording模式详解

进入recording模式

生效缓冲区的内容

实际例子

SMTP邮件服务器postfix配置与使用

postfix安装

安装cyrus-sasl-2.1.23

将sasl与postfix结合

【编程之美】单链表是否存在环以及环入口的位置【转载】

socket编程中如何区分不同的网络连接

平面中两点的最近距离与最远距离

关于编译器字节对齐的解释与原因

linux中有关用户与组的命令小结

C++沉思录读书笔记：句柄类的实现

句柄类的实现方法

C++沉思录读书笔记：类设计者的核查表

redis中常用数据结构介绍

1. 常用数据结构

2. 支持的数据类型实现

redis中sorted set的实现原理

redis源码分析资料

有关本站redis的内容请点击这里

C++ Web编程

C++ Web编程

第一CGI程序

Hello World! This is my first CGI program

C++ CGI库

C中宏使用小贴士与小技巧[原创]

C中宏使用小贴士与小技巧

Pthreads并行编程之spin lock与mutex性能对比分析[zz]

详细信息请点击：这里

linux下跨线程的越界访问hook方法

drupal号称比wordpress更强大

linux查看系统的启动时间和运行时间

字符串的哈希算法hnv的介绍和实现

sheepdog源码分析之关键模块介绍(一)

1) Worker工作线程模块

sheepdog源码分析之关键数据结构介绍

关键数据结构的说明

C语言中宏定义的##连接符和#转换符的用法介绍

sheepdog源码学习二之代码目录结构介绍

目录结构

Vim纵向编辑模式的用法

启动方法

2. 前向添加：添加字符串ping -c 4

3，qemu 0.13的安装（略）