kamuszhou's blog

Sample Page

Tue, 06 Jun 2023 10:21:03 +0000

This is an example page. It’s different from a blog post because it will stay in one place and will show up in your site navigation (in most themes). Most people start with an About page that introduces them to potential site visitors. It might say something like this:

Hi there! I’m a bike messenger by day, aspiring actor by night, and this is my website. I live in Los Angeles, have a great dog named Jack, and I like piña coladas. (And gettin’ caught in the rain.)

调研号称最快的快速傅里叶变换库fftw

Fri, 13 May 2022 04:04:24 +0000

调研主流开源fft c/c++库，最后选择了最为知名的fftw项目。读完了官方最新版手册的大部分内容。和当前项目使用的简单实现做bechmarking，fftw的速度在我的测试环境中比简单实现快30~40倍。测试环境: AMD 4G主频

	44.1K采样10分钟	44.1K采样1分钟	44.1K采样10秒
简单实现	2.01017秒	0.203767秒	0.037936秒
fftw	0.047039秒	0.00466秒	0.001126秒
summary	42.3倍	43.7倍	33.7倍

帧长都是1024, 帧跳512。

虽然fftw的性能领先得非常地明显，但如果每一分钟左右，甚至更短的时间就计算一次，简单fft也能在一秒钟内完成。看来fft并非主要耗时部分。这次调研fft算法更新了我对fft的看法。我印象中FFT仅管是快速算法，仍然非常耗时，所以才需要DSP芯片。看来现在的通用CPU亦能应付大部分场景。

Linux下接链Matlab的库，它们在哪里～

Thu, 03 Mar 2022 08:21:26 +0000

这篇短博客就记一下matlab把库文件放哪～

64-bit Apple Mac	64-bit Linux
matlabroot/bin/maci64:matlabroot/sys/os/maci64	matlabroot/bin/glnxa64:matlabroot/sys/os/glnxa64

mac用的是名字是maci64， linux用的名字是glnxa64。
好奇怪的名字, glnxa ? 是不是 Gnu LiNuX Archives 的缩写呢？google了一会儿没找到答案。

用FFmpeg5.0 + SDL3 播放视频

Tue, 15 Feb 2022 02:23:38 +0000

上个月看完了讲H.264视频编解码的经典书：“The H.264 Advanced Video Compression Standard”，看完后感觉也不是那么难。记得大约十年前第一次看到预测(prediction), 运动补偿(motion compensation)之类的术语和示意图，感觉是非常晦涩难懂的知识。而现在补了基础信号理论的知识，也扫除了很多畏难心理。

后来了解到比较常用的开源H.264编码器是X264，而FFmpeg则自带一个广泛使用的开源H.264解码器。于是，我就想对照着开源代码，再过一遍理论知识。那就选FFmpeg吧～毕竟名气太大。

首先，得用FFmpeg整一个简单的播放器跑起来才能调试。但是，网络上虽然有大量FFmpeg编写简单播放器的代码，绝大部分代码却是无法用最新的FFmpeg通过编译的。毕竟FFmpeg在持续开发中，连上层API也会有变化。我下载了目前(2022/Feb/13)最新的代码，版本号是5.0。旧FFmpeg播放器代码跑不起来。

好在我在youtube.com上找到一位FFmpeg核心维护者Matt Szatmary做的presentation，An Introduction to Building tools with FFmpeg libraries and APIs – Matt Szatmary | August 2019{.wp-editor-md-post-content-link}，结合它的介绍，把简单的播放功能跑起来了。这里有个小遗憾没能找到Matt Szatmary的源代码，虽然他在视频中说是开源的。本来还想学习一下大佬的写法。

代码贴在这里。用这个小DEMO可以用调试器跟到FFmpeg的代码里看H264解码器的具体实现了。

#include <stdio.h>
#define __STDC_CONSTANT_MACROS
// Linux...
#ifdef __cplusplus
extern "C"
{
#endif
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
#include <libswscale/swscale.h>
#include <libavutil/imgutils.h>
#include <SDL2/SDL.h>
#ifdef __cplusplus
};
#endif

int sfp_refresh_thread(void *opaque);

// Refresh Event
#define SFM_REFRESH_EVENT (SDL_USEREVENT + 1)
#define SFM_BREAK_EVENT (SDL_USEREVENT + 2)
int thread_exit = 0;
int thread_pause = 0;

int sfp_refresh_thread(void *opaque)
{
    SDL_Event event;

    thread_exit = 0;
    thread_pause = 0;
    while (!thread_exit)
    {
        if (!thread_pause)
        {
            SDL_Event event;
            event.type = SFM_REFRESH_EVENT;
            SDL_PushEvent(&event);
        }
        SDL_Delay(40);
    }
    thread_exit = 0;
    thread_pause = 0;
    // Break
    event.type = SFM_BREAK_EVENT;
    SDL_PushEvent(&event);
    return 0;
}

int main(int argc, char *argv[])
{
    AVFormatContext *pFormatCtx;
    int i, videoindex;
    AVCodecParameters *pCodecPar;
    AVCodecContext *pCodecCtx;
    const AVCodec *pCodec;
    AVFrame *pFrame, *pFrameYUV;
    unsigned char *out_buffer;
    AVPacket *packet;
    int ret, got_picture;
    //------------SDL----------------
    int screen_w, screen_h;
    SDL_Window *screen;
    SDL_Renderer *sdlRenderer;
    SDL_Texture *sdlTexture;
    SDL_Rect sdlRect;
    SDL_Thread *video_tid;
    SDL_Event event;
    struct SwsContext *img_convert_ctx;
    char filepath[] = "video";

    // avformat_network_init();
    // pFormatCtx = avformat_alloc_context();
    pFormatCtx = NULL;    // MYNOTE: if pFormatCtx is not allocated explicitly using avformat_alloc_context()
    // pFormatCtx will be allocated implicitly in avformat_open_input.
    if (avformat_open_input(&pFormatCtx, filepath, NULL, NULL) != 0)
    {
        printf("Couldn't open input stream.\n");
        return -1;
    }
    if (avformat_find_stream_info(pFormatCtx, NULL) < 0)
    {
        printf("Couldn't find stream information.\n");
        return -1;
    }
    videoindex = -1;
    for (i = 0; i < pFormatCtx->nb_streams; i++)
        if (pFormatCtx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
        {
            videoindex = i;
            pCodecPar = pFormatCtx->streams[i]->codecpar;
            break;
        }
    if (videoindex == -1)
    {
        printf("Didn't find a video stream.\n");
        return -1;
    }

    pCodec = avcodec_find_decoder(pCodecPar->codec_id);
    if (pCodec == NULL)
    {
        printf("Codec not found.\n");
        return -1;
    }
    pCodecCtx = avcodec_alloc_context3(pCodec);
    if (!pCodecCtx)
    {
        fprintf(stderr, "Could not allocate video codec context\n");
        exit(1);
    }
    // 这一步不能少，否则会崩溃。把CodecPar的参数再复制到codecCtx中
    ret = avcodec_parameters_to_context(pCodecCtx, pCodecPar);
    if (ret < 0)
    {
        printf("avcodec_parameters_to_context failed...");
        return -1;
    }
    // pCodecCtx = pFormatCtx->streams[videoindex]->codecpar;
    if (avcodec_open2(pCodecCtx, pCodec, NULL) < 0)
    {
        printf("Could not open codec.\n");
        return -1;
    }
    pFrame = av_frame_alloc();
    pFrameYUV = av_frame_alloc();
    size_t sz = av_image_get_buffer_size(AV_PIX_FMT_YUV420P, pCodecCtx->width, pCodecCtx->height, 1);
    out_buffer = (unsigned char *)av_malloc(sz);
    av_image_fill_arrays(pFrameYUV->data, pFrameYUV->linesize, out_buffer,
                         AV_PIX_FMT_YUV420P, pCodecCtx->width, pCodecCtx->height, 1);
    // Output Info-----------------------------
    printf("---------------- File Information ---------------\n");
    av_dump_format(pFormatCtx, 0, filepath, 0);
    printf("-------------------------------------------------\n");
    img_convert_ctx = sws_getContext(pCodecCtx->width, pCodecCtx->height, pCodecCtx->pix_fmt,
                                     pCodecCtx->width, pCodecCtx->height, AV_PIX_FMT_YUV420P,
                                     SWS_BICUBIC, NULL, NULL, NULL);
    if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO |
                 SDL_INIT_TIMER))
    {
        printf("Could not initialize SDL - %s\n", SDL_GetError());
        return -1;
    }
    // SDL 2.0 Support for multiple windows
    screen_w = pCodecCtx->width;
    screen_h = pCodecCtx->height;
    screen = SDL_CreateWindow("Simplest ffmpeg player's Window",
                              SDL_WINDOWPOS_UNDEFINED,
                              SDL_WINDOWPOS_UNDEFINED,
                              screen_w, screen_h, SDL_WINDOW_OPENGL);
    if (!screen)
    {
        printf("SDL: could not create window - exiting:%s\n", SDL_GetError());
        return -1;
    }
    sdlRenderer = SDL_CreateRenderer(screen, -1, 0);
    // IYUV: Y + U + V (3 planes)
    // YV12: Y + V + U (3 planes)
    sdlTexture = SDL_CreateTexture(sdlRenderer,
                                   SDL_PIXELFORMAT_IYUV,
                                   SDL_TEXTUREACCESS_STREAMING, pCodecCtx->width, pCodecCtx->height);
    sdlRect.x = 0;
    sdlRect.y = 0;
    sdlRect.w = screen_w;
    sdlRect.h = screen_h;
    packet = (AVPacket *)av_malloc(sizeof(AVPacket));
    video_tid = SDL_CreateThread(sfp_refresh_thread, NULL, NULL);
    //------------SDL End------------
    // Event Loop
    for (;;)
    {
        char buf[1024];
        int ret;
        // Wait
        SDL_WaitEvent(&event);
        if (event.type == SFM_REFRESH_EVENT)
        {
            while (1)
            {
                if (av_read_frame(pFormatCtx, packet) < 0)
                    thread_exit = 1;
                if (packet->stream_index == videoindex)
                    break;
            }

            // ret = avcodec_decode_video2(pCodecCtx, pFrame, &got_picture, packet);
            // ret = my_decode();
            ret = avcodec_send_packet(pCodecCtx, packet);
            if (ret < 0)
            {
                fprintf(stderr, "Error sending a packet for decoding\n");
                exit(1);
            }

            while (ret >= 0)
            {
                ret = avcodec_receive_frame(pCodecCtx, pFrame);
                if (ret == AVERROR(EAGAIN))
                {
                    fprintf(stderr, "EAGAIN occurred...\n");
                    break;
                }
                if (ret == AVERROR_EOF)
                {
                    printf("byebye...\n");
                    exit(0);
                }
                if (ret < 0)
                {
                    fprintf(stderr, "Error during decoding\n");
                    exit(1);
                }

                printf("Got frame %3d\n", pCodecCtx->frame_number);
                fflush(stdout);

                /* the picture is allocated by the decoder. no need to
                   free it */
                // snprintf(buf, sizeof(buf), "%s-%d", "player.c", dec_ctx->frame_number);
                // pgm_save(frame->data[0], frame->linesize[0], frame->width, frame->height, buf);

                sws_scale(img_convert_ctx, (const unsigned char *const *)pFrame->data,
                          pFrame->linesize, 0, pCodecCtx->height, pFrameYUV->data, pFrameYUV->linesize);
                // SDL---------------------------
                SDL_UpdateTexture(sdlTexture, NULL, pFrameYUV->data[0],
                                  pFrameYUV->linesize[0]);
                SDL_RenderClear(sdlRenderer);
                SDL_RenderCopy(sdlRenderer, sdlTexture, NULL, NULL);
                SDL_RenderPresent(sdlRenderer);
                // SDL End-----------------------
            }

            // av_free_packet(packet);
            av_packet_unref(packet);
        }
        else if (event.type == SDL_KEYDOWN)
        {
            // Pause
            if (event.key.keysym.sym == SDLK_SPACE)
                thread_pause = !thread_pause;
        }
        else if (event.type == SDL_QUIT)
        {
            thread_exit = 1;
        }
        else if (event.type == SFM_BREAK_EVENT)
        {
            break;
        }
    }
    sws_freeContext(img_convert_ctx);
    SDL_Quit();
    av_frame_free(&pFrameYUV);
    av_frame_free(&pFrame);
    avcodec_free_context(&pCodecCtx);
    avcodec_close(pCodecCtx);
    avformat_close_input(&pFormatCtx);

    return 0;
}

adonisjs5的Ioc机制初探

Mon, 20 Dec 2021 05:18:33 +0000

什么是Ioc

Ioc(Inversion of Control)是一种设计模式.它指的是使用某对象/资源的代码,不负责该对象的依赖对象的创建和维护,而交给一个专门的容器来负责.这样,怎么创建对象的控制权就转移到了这个专门的容器,即实现了所谓的控制反转.Ioc用来降低对象之间由依赖关系产生的耦合.（按照软件工程理论,依赖算是最弱的一种耦合了.依赖 < 关联 < 聚合 < 组合< 继承）我感觉,Ioc算是一个升级版的工厂模式,它管理了大量的工厂函数和对应的资源名称.可以把创建资源/对象的依赖写在Ioc里面.

adonisjs5中的Ioc

我感觉有点奇怪,adonisjs5的官方文档中没有专门提及Ioc. https://docs.adonisjs.com/guides/introduction{.wp-editor-md-post-content-link} 但在adonisjs4.x https://legacy.adonisjs.com/docs/4.1/ioc-container{.wp-editor-md-post-content-link} 的官方文档中却有单独的一节来讲Ioc.以至于,我第一次读完adonis5的文档后,对Ioc竟然没什么印象.而Ioc却是adonis最为重要的概念.anyway~,看看adonis的源代码怎么处理Ioc吧.

注册Ioc

在adonisjs的代码中搜索一下,

find node_modules/@adonisjs -iname "*ioc*"

很容易发现adonisjs实现Ioc的代码在node_modules/@adonisjs/fold/build/src/Ioc/这个目录中.目录名就是Ioc,毫不掩饰自己的目的.
逛一逛Ioc这个目录下的js文件,发现最重要的是index.js 和 binBindings.js这两个文件.其中index.js中有一个类就叫Ioc, 而注册到Ioc中的资源被放在Bindings.js文件中Bindings类中.

    /**
     * Define a binding
     */
    register(binding, callback, singleton) {
        this.list.set(binding, { callback, singleton });
        return this;
    }

Binding类中的register函数非常显眼.显然注册一个资源到Ioc的代码会走到这里.在这里下断点,调起调试器.发现register函数的三个参数的含义是： binding即资源的的namespace,通过调试器发现注册的第一个资源的namespace是“Adonis/Core/Application”；callback相当于创建这种资源的工厂函数,调用它即生产出一个对应的对象；而singleton则是一个boolean值,指示该种资源是不是一个单件.看看栈的上一个frame,是Ioc类的singleton()函数.看来,“Adonis/Core/Application”这个资源是通过Ioc.singleton()创建的.

    /**
     * Same as the [[bind]] method, but registers a singleton only. Singleton's callback
     * is invoked only for the first time and then the cached value is used
     */
    singleton(binding, callback) {
        helpers_2.ensureIsFunction(callback, '"ioc.singleton" expect 2nd argument to be a function');
        this.bindings.register(binding, callback, true);
        return this;
    }

Ioc.singleton()函数注释告诉我们.single()函数跟bind()函数一样,只不过是注册一个单件,单件的callback工厂函数仅调用一次.第一次创建会把资源cache起来,而后直接返回cache.这个cache即Bindings类中的list成员.虽然名字是list,但却是一个Map.映射namespace到对象/资源.

Fiduccia Mattheyses算法(即FM算法)的论文解读

Sat, 11 Dec 2021 15:35:42 +0000

kamuszhou的博客，转载请注明URL。

现代大规模集成电路图（VLSI）非常庞大，当我们希望用多个FPGA仿真一个VLSI时，需要把VLSI在满足一些约束条件的情况下切割成多个小部分，每个部分都可以装进一个FPGA。

这个问题抽象成数学模型，实际上就是一个超图分割的问题。在超图分割领域有一篇发表于1982年的论文，名字是”A Linear-Time Heuristic for Improving Network Partitions”。这篇论文提出了一种改进的“超图二分问题”算法，简称为FM算法。虽然在1982年这篇论文发表时，“超图分割”算法领域已经发展了近十年。但这篇论文似乎有着近乎祖师爷级论文的地位，相当多的后期该领域的论文都会引用这篇文章。论文发表之后该领域继续发展出的“层次化超图多分割”算法可以看成是FM算法发展而来。该算法中涉及到的概念和思路是后续算法的基础，是很好的该领域入门学习的资料。
（更多超图及超图分割的基础概念请自行搜索，本博客主要解读论文）

论文的下载地址：
https://ieeexplore.ieee.org/document/1585498{.wp-editor-md-post-content-link}

在论文的摘要部分论述到：本文提出了一种启发式的，利用最小割(mincut)的迭代算法解决超图二分问题。该算法在最坏情况下的时间复杂度也是线性的。在实际应用中，绝大多数情况下，该算法都只需要很少次数的迭代。算法有三个特点：

超图被分成两个Block。每次移动一个结点把它从原来的Block移往另一个Block。同时维持两个Block的平衡。重要的是，这个平衡不是基于每个Block中的结点数量，而是更一般的size of block的概念，它考虑到了每个结点的权重是不一样的。
利用一个相当高效的数据结构，可以在O(1)常数时间复杂度内找到需要移动的最佳结点。
在移动了某个结点后，再高效地更新受上次移动影响的结点的信息(即论文后面会提到的结点的gain值)。这第三个特点亦在论文的Introduction中被再次提到，作者认为这是该论文的主要贡献(main contribution).

术语及基本概念

n(i): 当i是超边的编号时，n(i)定义为每个超边上的结点数目。
s(i)或p(i): 当i表示结点时，s(i)或p(i)表示结点上的PIN数目，即结点一共跟多个条超边有连接，更多时候亦称为结点的size。
邻居结点：如果两个结点至少能通过一条超边连接，即为邻居结点。
A，B：代表超图二分割后的两个BLOCK。
｜A｜： $|A| = \sum_{i=i}^{n}{s(i)}$ 即Block A的size定义为Block A中所有的结点的size的连加。
A(n)或B(n)： n表示编号为n的边，A(n)则表示该条n在Block A中的结点数。
cut: 在A和B中都有结点的超边。
cutstate: 一条超边是不是cut（后来发展成多分割问题中的cutsize）。
cell gains: 当移动一个结点到另一个BLOCK时，cut减少的数目。

维持平衡

最容易想到的是就是使超图二分割后的两个BLOCK中的结点数量大致相同。不过，可以稍微变复杂一点，即考虑每个结点的权重。

W ＝ |A| + |B| 所有结点的size连加和
r = |A| / (|A| + |B|) 一个大小0到1之间的比率
smax = $\max_{1<i<n}{s(i)}$ 最大的结点size
* rW – k ＊ smax <= |A| <= rW + k * smax；k > 1 平衡公式

公式不难，描述地很清楚。简单地讲，block的size考虑到了每个结点的权重不同。另外，允许每个block的size在满足比率r的附近上下浮动k个最大结点size。它的含义是，在刚好满足分割比率r的时候，还能够至少移动k个结点。

如何知道gcc/g++ 的默认C++版本

Sun, 21 Nov 2021 12:48:51 +0000

C++在C++ 11之后在保持向后兼容的情况下，语法增强了非常多，变化很大。得益于Move语义，和一些标准库的改进（如std::list的size()函数在C++11之前是O(n)的复杂度，从C++11开始变成常数复杂度）。一些旧C++代码即使什么改动也不做，只需要在新的C++标准下编译，也能获得性能提升。一般要给g++开启C++11需要用 -std=c++11，开启C++17则是 -std=c++17。那么，如果不添加这些选项，gcc/g++默认使用的C++版本号是什么呢？

如果你的gcc/g++版本号大于4.7的话，可以用如下命令获得默认c++版本。

kamus@shyyp.net:~$ g++ --version | head -1
g++ (Ubuntu 9.3.0-17ubuntu1~20.04) 9.3.0
kamus@shyyp.net:~$ g++ -dM -E -x c++  /dev/null | grep -F __cplusplus
#define __cplusplus 201402L
kamus@shyyp.net:~$ gcc -dM -E -x c++  /dev/null | grep -F __cplusplus    ＃其实用gcc也可以
#define __cplusplus 201402L

如上所示，我的g++版本是9.3.0。它的默认C＋＋版本是C＋＋14。
这是我家用的电脑。我在公司的机器上运行结果如下：

kamuszhou@centos ~ $ g++ --version | head -1
g++ (Ubuntu 4.8.4-2ubuntu1~14.04.3) 4.8.4
kamuszhou@centos~ $ g++ -dM -E -x c++  /dev/null | grep -F __cplusplus
#define __cplusplus 199711L

如上所示，老版的g++ 4.8.4用的默认C++版本还是c++98

安卓平台下面开发DSP应用

Fri, 18 Jun 2021 01:24:40 +0000

这两天考察在手机上面写DSP应用的可能性，找了一些资料读了，有这些困难：

安卓平台：
谷歌有一个叫Oboe的C++库帮助开发音频APP，但是官方文档只提供了一些简单的例子，没有给出类似效果器之类有复杂数学运算的例子。我担心很多DSP运算的实时性得不到保证。

得有DSP芯片的配合才能写出高效的DSP算法，虽然 arm CPU集成有DSP芯片，但是要充分利用DSP的指令，得用arm的付费编译器，据说挺贵的。而且，如果用DSP的指令优化算法，

安卓碎片化的问题有更多的坑。如果用了非常底层的代码（直接写死了DSP的指令），代码在不同的机器上可能表现很不一样，很可能有些机器跑不起来。

一篇2014年的技术文章 https://www.androidauthority.com/state-audio-android-414978/{.wp-editor-md-post-content-link} 讲在android平台下面开发DSP的应用很困难。虽然是7年前的文章，但也很有参考价值。

苹果iOS：
苹果对DSP有很好的支持，但是我没有Mac电脑也没有iphone手机，没办法做开发。

不过，有一个superepowered的开源库，声称完美提供了开发DSP的能力。但是这个库不是完全免费的。官网上也没有明确价格，需要Contact sales。 https://superpowered.com/pricing{.wp-editor-md-post-content-link}
那算了，没太大兴趣了解。

用琴生(Jensen)不等式证明期望最大值(EM)算法收敛

Sun, 13 Jun 2021 04:04:43 +0000

今年二月份刷了一遍“机器学习白板推导”系列视频。https://www.bilibili.com/video/BV1aE411o7qd 。这个机器学习的公式推导系列讲地真是太好了，当时像追剧一般花了两个星期听完。非常感谢录这个视频系列的老师shuhuai008。不过，因为以前机器学习的基础几乎为0，又没有动手做相关练习。三个半月以后，又忘了很多了。昨天，我想起要复习一下EM算法，于是又把视频捡起来找到EM算法的部分，复习一下。

第二次看，果然快了很多。不过，在用琴生不等式证明EM算法收敛的部分，卡住了。我不断回忆第一次看的时候是如何理解的，奈何回忆不起来了。于是，找到Jensen不等式的词条看了看，琢磨了好久。终于懂了，在这里把这个思考过程记下来。

我卡在这个步骤：需要用Jensen Inequality证明如下不等式：
[latex]
\int\limits_z P(z|x, \theta^{(t)}) \log_{}{\frac{P(z|x, \theta^{(t+1)})}{P(z|x, \theta^{(t)})} } dz \le 0
[/latex]
上面公式中的z表示模型中的隐变量，x表示观测值，$ \theta $是参数，$ \theta^{(t)} $表示theta在第t时刻的值（EM算法是一个迭代算法）。

证明这个不等式需要用到琴生不等式在凹函数上的性质。如下：
设f(x)中一个凹函数（凹函数图形和中文字凹的形状相反，可以理解为上凸，log函数即一个凹函数）,下面的不等式成立。
$$
a_1f(x_1) + a_2f(x_2) + \dots + a_nf(x_n) \le f(a_1x_1 + a_2x_2 + \dots + a_nx_n)
且 a_1 + a_2 + \dots + a_n = 1
$$
用自然语言描述是：凹函数定义域内的n个自变量对应的因变量的线性组合小于或等于n个自变量先做线性组合再求对应的因变量，作线性组合的系数之和为1。简单地说：先求函数值再做线性组合小于或等于先做线性组合再求函数值。

再回到我们要证明的不等式。积分号即可看成是无穷多个值的线性组合，对数符号log后面对应的那一坨
$$ {\frac{P(z|x, \theta^{(t+1)})} {P(z|x, \theta^{(t)})} } $$
看成是log函数的因变量，log前面的
$$
P(z|x, \theta^{(t)})
$$
看成是线性组合的系数，很明显这个系数是满足积分和为1的概率密度。于是，就可以套用上面提到的凹函数上的琴生不等式。不等式的右边为0，左边是“先求函数值再做线性组合”，化简为左边小于“先做线性组合再求函数值”：
$$
\begin{aligned}
左边 &\le log_{}{\int\limits_z {\frac{P(z|x, \theta^{(t+1)})} {P(z|x, \theta^{(t)})} } P(z|x, \theta^{(t)})}dz \&=log_{}{}\int \limits_zP(z|x,\theta^{(t+1)})dz=log_{}{1}=0
\end{aligned}
$$
得证！

使用tailwindcss创建一个全屏模式对话框

Sun, 09 Aug 2020 10:42:00 +0000

最开始用的css UI库是最常用，历史最悠久的bootstrap。后来又接触了bulma，bulma也做得很漂亮，不过我没有把bulma用在实战中。前段时间打算改版我的粤语网站https://ykyi.net{.wp-editor-md-post-content-link}, 调研了多种技术方案，最终选中了nextjs{.wp-editor-md-post-content-link}。读nextjs官方文档时发现tailwind是nextjs默认配好的css库。这是第一次接触到tailwindcss{.wp-editor-md-post-content-link}。较之Bulma和bootstrap这些UI库给了开箱即用的很多控件，tailwind只是提供了很多css工具(css类)，用户需要用这些工具自己创建最终使用的控件。一开始会让人有点畏惧，实际使用之后，其实完全自己创建美观的UI控件也并非有那么困难。

今天用tailwind做了一个全屏的模式对话框Modal Dialog。代码实际上是从网上抄下来的。天下代码我抄你，你抄我嘛～～
HTML代码如下。


<div className=“bg-gray-200 flex items-center justify-center h-screen”>
<button className=“modal-open btn btn-green”>Open Modal</button>

<div className=“modal opacity-0 pointer-events-none fixed w-full h-full top-0 left-0 flex items-center justify-center”>
<div className=“modal-overlay absolute w-full h-full bg-gray-900 opacity-50”></div>
&lt;div className="modal-container bg-white w-11/12 md:max-w-md mx-auto rounded shadow-lg z-50 overflow-y-auto"&gt;
  &lt;div className="modal-content py-4 text-left px-6"&gt;
    &lt;div className="flex justify-between items-center pb-3"&gt;
      &lt;p className="text-2xl font-bold"&gt;Simple Modal!&lt;/p&gt;
      &lt;div className="modal-close cursor-pointer z-50"&gt;
        &lt;svg className="fill-current text-black" xmlns="http://www.w3.org/2000/svg" width="18" height="18" viewBox="0 0 18 18"&gt;
          &lt;path d="M14.53 4.53l-1.06-1.06L9 7.94 4.53 3.47 3.47 4.53 7.94 9l-4.47 4.47 1.06 1.06L9 10.06l4.47 4.47 1.06-1.06L10.06 9z"&gt;&lt;/path&gt;
        &lt;/svg&gt;
      &lt;/div&gt;
    &lt;/div&gt;

    &lt;p&gt;Modal content can go here&lt;/p&gt;
    &lt;p&gt;...&lt;/p&gt;
    &lt;p&gt;...&lt;/p&gt;
    &lt;p&gt;...&lt;/p&gt;
    &lt;p&gt;...&lt;/p&gt;

    &lt;div className="flex justify-end pt-2"&gt;
      &lt;button className="btn btn-green m-2"&gt;Action&lt;/button&gt;
      &lt;button className="modal-close btn btn-green m-2"&gt;Close&lt;/button&gt;
    &lt;/div&gt;

  &lt;/div&gt;
&lt;/div&gt;

</div>

讲讲为什么要用javascript的requestAnimationFrame函数在web上实现复杂动画效果

Thu, 05 Mar 2020 04:17:12 +0000

简单地讲，requestAnimationFrame函数更适合在浏览器上面做复杂的动画。比用定时器效率高。

废话如下：

现代的WEB世界(2020年)，网页上各种各样的内容丰富多彩。虽然css也能完成很多简单的动画，但是仍然有一些复杂的动画animation需求需要javascript处理。之前，我简单地理解，浏览器已经有定时器函数setTimeout()和setInterval(),就足够做出复杂的动画形式。原来，不是这样的。

这段时间在做一个运行在浏览器上的红白机模拟器，参考开源代码，发现用的是requestAnimationFrame()函数。于是，查了一些资料，涨了知识。

首先，使用定时器SetTimeout和setInterval做动画有两个大缺点。

受有限的资源，或者糟糕的cpu密集的业务代码的影响。浏览器并不严格按照定时器函数中的时间间隔参数来调度定时回调函数。比如50ms，有时会快，有时会慢。这样，动画效果的帧与帧之间的画面就不会那么流畅了。
频繁的调用计时器函数setTimeout或setInterval，可能导致浏览器假死。浏览器竭尽全力的处理一些跟动画无关的代码，比如文档流的不断重排。这样，用户的界面根本没有获得重新渲染的机会。特别在手机浏览器，由于手机的环境比较特殊。手机的电池可以不够，网络不好，都可能影响web页面的文档重排（page reflow）的效率。

为什么用requestAnimationFrame

针对定时器的缺点1，浏览器的实现保证requestAnimationFrame设定的回调函数会严格定时执行。当然是在web页是活跃状态，即不是在后台运行。等下会讲到后台执行时的情况。一般浏览器调用requestAnimationFrame设定的回调函数的频率是每秒60次。不同浏览器的实现有不变。
当web页面被放入后台运行时，浏览器会大辐降低requestAnimationFrame设置的回调函数调用频率。低至每秒两次，甚至暂停。这样，又能节省相当多的资源。比如手机上珍贵的电池资源。非常容易理解，web页面不可见的时候，还继续渲染画面是完全没有意义的。

需要注意的地方

既然requestAnimationFrame的调用频率因浏览器而异，另外页面在后台时又可能会暂停。所以，生成动画的代码不能预设回调函数以某一个固定的频率执行。解决这个问题，requestAnimationFrame的回调函数会传入一个时间戳参数，

下面是官方文档对传入回调函数的时间参数的解释，给了一个高精度的时间戳，单位是毫秒。嗯，对于浏览器来说，如果能精确到毫秒的话，算得上高精度的时间戳了。

The callback function is passed one single argument, a DOMHighResTimeStamp similar to the one returned by performance.now(), indicating the point in time when requestAnimationFrame() starts to execute callback functions

Tokio简介

Sun, 16 Feb 2020 13:28:36 +0000

什么是Tokio

Tokio是一个事件驱动的运行时(官网用词runtime)，用来编写rust异步代码。所谓异步代码，即和同步代码对应而言。比如同步读磁盘上的文件：应用代码调用读文件的函数，函数封装了操作系统的系统调用，通知操作系统读入文件内容，操作系统把文件内容全部读出后才回到应用代码，继续执行之后的逻辑。在操作系统读文件内容的过程中，应用程序无所事事，默默地等待。而异步读入文件内容，异步调用通知操作系统读文件后立即返回，应用程序有机会在操作系统读文件时干其他事情，当操作系统读完文件内容后会以某种形式通知应用程序读文件已经完成

Tokio为异步编程提供了这些东西：

一些基本工具。比如同步原语(synchronization primitives)，管道(channels)，计时器，延时，intervals(不知道这是什么东西，描述一个时间间隔么？)。
API。网络相关的tcp,udp异步函数，异步文件操作函数，异步的进程和信号管理。
调度器，用来调度tasks(类似其他语言的异步框架的绿色线程或协程的概念)。
I/O驱动(官网用语IO driver)，使用原生操作系统的事件队列接口。比如:linux下的epoll,freeBSD下的kqueue，windows下的IOCP。
高性能的计时器。

快速 Fast

Tokio使用的是Rust编程语言，当然有资格有能力做到快速。Tokio要设计时也把速度放在非常重要的位置。

零开销抽象 Zero-cost abstractions

Tokio广泛使用Future这个异步概念(类似node.js中的promise，据我理解，不同语言的异步框架中使用的future和promise是非常近似的概念)。官方文档声称tokio的future和其他语言的future实现不一样。它是独一无二的(unique)。Tokio中的future会被编译器编译成一个状态机。做异步事件的同步处理时，分配内存，及其他future的实现中有开销的地方，tokio都是零开销。(我觉得协程类的异步框架都要维护状态机用来记录栈的信息么,状态机并不unique。unique的是零开销抽象)。

零开销抽象并不意味着tikio自身没有开销，而指是不可能再用其他什么方法减少开销，开销已经减到最少。

并发 Concurrency

Tokio提供了一个多线程，work-stealing(不知用哪个中文合适)的调度器。Tokio是开箱即用的，意味着，当你使用tokio运行时的时候，你就可能充分利用电脑上所有的cpu核心。

现代计算机通过增加中央处理器的核心来增加性能。所以，能够利用好多核心对于高性能的应用来说是至关重要的。

非阻塞I/O Non-blocking I/O

tokio使用操作系统原生的多路复用技术(linux的epoll,freeBSD的kqueue,windows的IOCP)，一个线程可以同时管理多个socket。这样能减少系统调用(system call)，提高应用的性能。

可靠 Reliable

Tokio在设计时就竭尽所能避免应用程序因使用tokio不当产生BUG，但tokio当然不可能完全做到这点。Tokio的API设计得不易于用错。这样，在项目的最后一天，你就可以信心满满地交付了。

所有权和类型系统 Ownership and type system

Tokio籍由Rust语言特有的所有权系统和严格的类型安全，能避免很多内存安全方面的错误。它能避免绝大多数常见的内存出错：访问未初始化内存，访问释放后内存，内存重复释放（Double Free)。并且，做到这些并不需要付出运行时的额外开销。(回忆自己用C/C++写的复杂应用时追踪偶发的内存出错BUG真是无比痛苦。)

另外，严格的类型安全系统也使得难以错误使用API。比如，Tokio中的互斥锁并不需要开发者显式释放。(这一点并不稀奇，C++的RAII，Go的defer,python的with也能做到，稍微现代的语言都有类似机制。)

反向压力传递 Backpressure

Tokio自带了压力反向传递的功能，这真是真是一个让人称赞的功能，真香。所谓反向压力传递，可以这么理解：当消费者消费的速度小于生产者生产的速度时，数据会在内存中越堆越多，最终把内存撑暴。反向压消费力传递指的是，消费者的压力会反向传递给生产者，让生产者减慢生产的速度以匹配消费者的消费速度。很多其他的库并没有提供这个功能，于是应用需要自己实现一个。但要实现一个高性能的类似功能并不是一件容易的事情。（回忆起自己有段时间用C++的asio异步网络库写的服务器。我的实现是当存放任务的队列到达一个阈值时就让生产者线程sleep很短一段时间，再从网络中读取数据，生产任务，结果性能大降。我相信tokio一定优雅高效地提供了这个功能。）

tokio官方文档中表示，Tokio中的生产者天生是lazy的，它们会轮循消费者，只有当消费者充许增加数据时，生产者才生产数据。

取消 Cancellation

应用的业务代码持有一个future，它描述了异步计算的结果。如果当业务代码认为并不需要这个结果时，则可以不再持有这个future（让它的生命期结束）。这样，异步计算就会及时结束，不再执行不必要的计算。官方文档表示这主要受益于Tokio的轮循设计。

多谢了Rust的权限模型，异步执行部分能通过实现drop这个特征(trait，类似c++,c#,java的接口)，及时感知到future已经被丢弃了。

轻量级 Lightweight

Tokio的伸缩性很好，且伸缩时不给应用增加额外负担。这样，tokio能在资源受限的环境下发展得不错。

没有垃圾回收 No garbage collector

tokio使用的是rust语言，所有没有垃圾回收机制，也就避免了在有垃圾回收的语言中普遍存在的“世界暂停”问题。应用会周期性的启动垃圾回收，在极限性能要求的情况下，这个问题就会暴露出来。Tokio的这个特性使得它适合中实时环境中使用。

模块化 Modular

尽管Tokio提供了非常多开箱即用的功能，并且是用模块式的方式组织的。每一个component都使用一个独立的库library。用户可以精确的设定需要使用哪些特性而只导入相应的库，其他不需要使用的库则不会被编译进最终的应用程序中。很多其他著名的rust库也使用了tokio，比如hyper和actix。

Rust语言的宏编程极简教程Macro

Thu, 06 Feb 2020 09:51:08 +0000

Rust的宏和c/c++的异同

Rust语言的宏设计得比较复杂，当然也可以说功能非常强大，跟c/c++语言的宏非常不一样。
相同点 当然是宏能够让代码更精简，码农可以少敲很多样板代码(boilerplate code)。当然你说函数和类不也可以抽象代码，使代码精简吗？但宏能够获取很多在编译期的信息，函数和类却不能。比如，代码所在的文件和行数，这个信息只有宏才能获得。
不同点 是，C/C++的宏只是在预编译期简单地做模式替换，预编译后再交由编译器。c/c++的include头文件展开也是在预编译阶段。但Rust宏的展开不是发生在预编译期，而是编译期。于是Rust能够获得更复杂的更详细的编译器的信息。这里有两个概念Token Tree和AST。如果有大学阶段学习过的编译原理课程的背景就很容易理解。

Token Tree

Token Tree简写成TT。编译器拿到源代码后先做词法分析，即把源代码字节流分成一个一个的token。token和token之间的逻辑关系也记录下来。比如下面的一个简单语句：

a + b + (c + d[0]) + e

的Token Tree就长这个样子：

«a» «+» «b» «+» «(   )» «+» «e»
         ╭────────┴──────────╮
          «c» «+» «d» «[   ]»
                       ╭─┴─╮
                        «0»

AST

AST的全称是Abstract Syntax Tree，抽象语法树。编译器把Token Tree翻译成AST，这是一个更有利于编译器理解源代码的结构。上面的TT翻译成对应的AST后长这个样子：

              ┌─────────┐
              │ BinOp   │
              │ op: Add │
            ┌╴│ lhs: ◌  │
┌─────────┐ │ │ rhs: ◌  │╶┐ ┌─────────┐
│ Var     │╶┘ └─────────┘ └╴│ BinOp   │
│ name: a │                 │ op: Add │
└─────────┘               ┌╴│ lhs: ◌  │
              ┌─────────┐ │ │ rhs: ◌  │╶┐ ┌─────────┐
              │ Var     │╶┘ └─────────┘ └╴│ BinOp   │
              │ name: b │                 │ op: Add │
              └─────────┘               ┌╴│ lhs: ◌  │
                            ┌─────────┐ │ │ rhs: ◌  │╶┐ ┌─────────┐
                            │ BinOp   │╶┘ └─────────┘ └╴│ Var     │
                            │ op: Add │                 │ name: e │
                          ┌╴│ lhs: ◌  │                 └─────────┘
              ┌─────────┐ │ │ rhs: ◌  │╶┐ ┌─────────┐
              │ Var     │╶┘ └─────────┘ └╴│ Index   │
              │ name: c │               ┌╴│ arr: ◌  │
              └─────────┘   ┌─────────┐ │ │ ind: ◌  │╶┐ ┌─────────┐
                            │ Var     │╶┘ └─────────┘ └╴│ LitInt  │
                            │ name: d │                 │ val: 0  │
                            └─────────┘                 └─────────┘

AST图有排版有点乱，我懒得改了。这两人个图，TT和AST都是从 https://danielkeep.github.io/tlborm/book/mbe-syn-source-analysis.html 抄来的。您可以移步到那个页面。
重点来了，Rust语言的宏展开就发生在编译器生成了源代码的AST的时候。Rust语言的宏可以从AST获得非常丰富的信息，并操作AST。

Rust语言中的单位类型unit type是什么

Sun, 24 Nov 2019 10:39:09 +0000

每个学习Rust语言的读者碰到单位类型unit type ()的时候都非常疑惑这究竟是个什么鬼？
本文总结了stackoverflow上面的贴子 What is the purpose of the unit type in Rust?{.wp-editor-md-post-content-link}加上我自己的理解。

unit type是一个类型，有且仅有一个值，都写成小括号()
单元类型()类似c/c++/java语言中的void。当一个函数并不需要返回值的时候，c/c++/java中函数返回void，rust则返回()。但语法层面上，void仅仅只是一个类型，该类型没有任何值;而单位类型()既是一个类型，同时又是该类型的值。
单元类型()也类似c/c++/java中的null，但却有很大不同。 null是一个特殊值，可以赋给不可类型的值，例如java中的对象，c中指向struct实例的指针，c++中的对象指针。但在rust中，()不可以赋值给除单元类型外的其它的类型的变量，()只能赋值给()。
Rust标准库中使用单元类型()的一个例子是HashSet。一个HashSet只不过是HashMap的一个非常简单地包裹，写作：HashMap<T, ()>。HashMap的第二个泛型类型参数即用了单元类型()
可以用Result<(), MyErrorType>代替Option，某些开发者认为Result<(), MyErrorType>语义上能更简明地表示一个“结果”。

You could argue that Option is ‘better’, but I disagree; the Result’s naming conventions mean it’s explicitly clear what’s going on.

使用Prettier,Husky和lint-staged，在提交javascript代码前自动格式化代码

Sun, 24 Nov 2019 08:58:10 +0000

目标

为防止提交不合格的代码排版到仓库中，我们希望在提交前格式化代码，使之符合项目的代码格式规范，而且尽可能保证逻辑正确。即目标有两点：

对git staged的代码强行格式化，使符合规范。对于没有被staged的代码或文件，将完全忽略。
跑单元测试。只有通过了单元测试才能提交代码。

安装依赖

$ npm install --save-dev husky lint-staged

先安装husky和lint-staged。注间在安装husky之前需要确保工程目录已经是一个合法的git仓库。因为，安装husky时需要给git仓库安装预提交钩子(precommit hook)。
Lint-staged提供了一个关键的功能，它能找到所有被git staged的文件，而不是工程下面所有的文件，然后通过管道交给Prettier做格式化。

修改npm脚本

对npm script做如下改动：

  "scripts": {
    "precommit": "lint-staged"
  },
  "lint-staged": {
    "*.{js,jsx,json}": ["prettier --write", "git add"]
  }

scripts.precommit由Husky处理，它会依照配置在把代码正式提交到仓库前运行lint-staged(当然我们也可以配置其他命令）。
Lint-staged再找到属于它自己的配置部分，即lint-staged键下面的配置。
在此例中，所有staged状态的，且扩展名是.js, .jsx, 和.json文件都会自动交由Prettier做格式化，然后再提交。

为何一定要用lint-staged

You might wonder why we don’t just use Husky to run a few npm scripts.
你可以会疑惑，为什么一定要罗里罗嗦地用lint-staged，用Husky直接调用npm脚本不更简单么。
这是因为我们用lint-staged拿到staged状态的文件，而不是所有的文件。
你的node工程文件中可能已经有如下做代码格式化的脚本

"format": "prettier --write '**/*.{js,jsx}'"

你可能会因此如下配置

"lint-staged": {
  "*.{js,jsx,json}": ["npm run format", "git add"]
}

如果是这样配置的话，就没有必要用lint-staged了。因为，这样的配置会把prettier应用到所有匹配.js,.jsx.json的文件上，而不是仅staged状态的文件。

python用multiprocessing起子进程，父进程被杀掉时，如何让子进程也自动退出

Fri, 11 Oct 2019 11:55:07 +0000

最近用python3写了一段代码，代码会起一个子进程做一些辅助的事情。但发现父进程被杀死后，这个子进程变成了孤儿进程，仍然在运行。
起进程的代码大概如下：

from multiprocessing import Process, Queue
__q = Queue()
__p = Process(target=__run, args=(__q,))
__p.start()

很不方便，那怎样让父进程退出后，子进程也跟着退出呢。
一番google之后，原来可以用一行代码解决：

from multiprocessing import Process, Queue
__q = Queue()
__p = Process(target=__run, args=(__q,))
__p.daemon = True    # 加上这一行代码
__p.start()

设置子进程的daemon属性为True。这样，当在控制台上用ctrl-c，退发送SIGTERM杀掉父进程后，子进程也会跟着退出，不会成为孤儿进程。
参考python官方的解释：

daemon
The process’s daemon flag, a Boolean value. This must be set before start() is called.
The initial value is inherited from the creating process.
When a process exits, it attempts to terminate all of its daemonic child processes.

Rust中的&str和String有什么区别

Mon, 07 Oct 2019 11:59:41 +0000

&str和String让Rust初学者困惑不已。这里简单的介绍一个&str和String的区别。

String就像是Vec一样是动态分配在堆heap上的字符串类型，它指向一串UTF8编码的字节序。当需要拥有该字符串，要更改字符串的内容，要把字符串在线程之间传递，要在运行时动态创建字符串时使用此类型。

str也指向一串UTF8编码的字节序，但并不拥有指向的字符串，而仅仅只是一个“string slice”。slice的详细解释点链接。str绝大多数情况下以引用**&str**的形式出现。又被称为字符串字面值(string literal)。
和String指向的字符串肯定分配在堆上面不一样，str指向的字符串可能出现在各种地方：

在程序的全局静态空间(.text段？？)。一个string literal的类型和生命期是：&’static str。字符串的数据硬编码进生成的程序或库文件，但程序加运行时，字符串加载进内存。
分配在堆上面 String有一个方法是as_str,它返回一个&str,指向String管理的堆上面的字符串。另外，String有实现Deref<Target=str>这样一个Trait，让所有接受&str作为参数的函数，都可以传String的引用。编译器会自动把&String转成&str。
分配在栈上面 如下面的代码，变量stack_str的类型是&str,它指向栈上面的字符串。

use std::str;

let x: &[u8] = &[b'a', b'b', b'c'];
let stack_str: &str = str::from_utf8(x).unwrap();

如果以C++程序员的视角看String和&str。一个Rust的String类似std::string,完全拥有并管理（创建，销毁）需要的内存。而Rust的&str则类似char*（当然实际上要复杂很多），仅仅指向字符串，不负责管理对应的内存。

再看看String和&str的互转化：
&str转String可以用三种方法

    let a: String = "hello rust".into();
    let c: String = "hello rust".to_string();
    let b: String = String::from("hello rust");
    println!("{}", a);   // 都输出 hello rust
    println!("{}", b);
    println!("{}", c);

String转&str可以直接引用String类型的值或者调用String的as_str方法。

let a: String = String::from("hello rust");
let aaa: &str = &a;
let bbb: &str = a.as_str();

转载请注明出处链接 http://ykyi.net/2019/10/rust%E4%B8%AD%E7%9A%84str%E5%92%8Cstring%E6%9C%89%E4%BB%80%E4%B9%88%E5%8C%BA%E5%88%AB/

linux怎么把一个正在前台运行的进程用nohup放入后台运行

Fri, 14 Jun 2019 09:06:00 +0000

假设进程在控制台运行。
三个步骤：

ctrl + z 停止正在运行的进程
$ bg 命令把该进程放入后台
disown -h [job的序号] 后台的进程有类似%1, %2, %3的序号。

至此，一个正在控制台前台运行进程被放入后台，且忽略SIGHUP信号。这样，即使关闭了控制台，也不会杀死这个进程了。

python自制包并用pip免提交到pypi仅安装到本机

Sun, 02 Jun 2019 14:31:10 +0000

不得不说python的自制包的相关工具真是多且混乱，什么setuptools,什么distutils，什么wheel，什么egg！！怎么有这么多啊？？

而且我的需求且且是创建一个自制包管理自己常用的代码，也必不想提交到PyPI，仅仅只需要安装到本机就行。

下面就是几个关键步骤。

文件目录布局
├── package1
│ └──-├── init.py
| |── mod1.py
│ └── mod2.py
├── setup.py
|── README.md
编写setup.py文件，类似如下：

from setuptools import setup, find_packages

setup(
    name="kamustools",
    version="1.0.1",
    author="Kamuszhou",
    author_email="zausiu@gmail.com",
    description="tools used by kamuszhou exclusively.",
    license="BSD",
    keywords="kamus",
    url="https://ykyi.net",
    packages=find_packages(),
    long_description="Long descrition is actually short...",
    classifiers=[
        "Development Status :: 3 - Alpha",
        "Topic :: Utilities",
        "License :: OSI Approved :: BSD License",
    ],
)

python3 setup.py sdist bdist_wheel
pip install ./dist/kamustools-1.0.1.tar.gz

就这四步，其他各种功能，以后要用了再慢慢看吧，实在太庞杂了。满足我自己需求的这四个简单步骤就记录在这里。

Wikipedia维基百科为什么不放广告，是因为版权原因吗？

Mon, 29 Apr 2019 03:37:52 +0000

答：不！维基百科不投放广告，不是因为版权原因。

https://en.wikipedia.org/wiki/Wikipedia:Funding_Wikipedia_through_advertisements 维基官方对投放广告的官方解释：17点理由不投放广告，没有一点提到版权。

通篇只有一处提到版权，是创始人Jimmy Wales的一段话：

I believe that if we looked at putting ads into the search results page (only), with the money earmarked for specific purposes (with strong community > input into what those would be, either liberation of copyrights ….
我相信，如果我们把广告放到搜索结果中，由此筹到的钱可用于特殊用途（社区的大量投入将是版权的解放）

有人说：

像这种权威的百科站点，例如莫种性病的解释词条边上出现一个莆田医院的广告，会怎样？难以想象！这种事也就百度做得出来吧。

上面链接中维基官方给出的不放广告的解释中就有几点的意思一致。

Ads cheapen the encyclopedia 会让维基掉价;
Threat to neutrality of content 影响内容中立;
Conflict of interest 和用户利益冲突.
Inappropriate ads 广告内容可能不恰当

上面的官方链接还有一条很强的证据能证明维基不放广告和版权无关。

The right to fork. It is inherent in the use of an open license that projects can fork. Thus far the largest fork away from Wikimedia was by a large part of the Spanish Wikipedia community who left because advertising was being considered.

flask框架的回复中显示中文utf8字符，而不是unicode-escape字符串

Mon, 03 Dec 2018 11:41:55 +0000

今天在用flask框架写http服务的时候，发现调用flask的jsonify函数得到的http回复包中的字文是用unicode-escape string表示的。如下：

u5b57\u5173\u6ce8\u6211\u4eec\uff01

有些RESTful工具能够把unicode-escape字符串转成utf8，能够正常显示出中文。但很多编辑器和其它工具只能显示原本的unicode转义字符串，大大妨碍调试。解决方案是用flask的另一个函数：make_response解决这个问题。代码如下：

from flask import Flask, jsonify, make_response


def mk_utf8resp(js):
    '''
    传入一个字典，返回一个json格式的http回复。
    '''
    resp = make_response(json.dumps(js, ensure_ascii=False))
    resp.headers['Content-Type'] = 'application/json'
    return resp

把jsonify(js)换成mk_utf8resp(js)，问题解决。

netstat -s统计输出的所有字段详细解释

Fri, 23 Nov 2018 08:45:32 +0000

今天工作上碰到一个问题需要知道udp的丢包数据。实际上我不相信能简单地得到udp的丢包精确数据。理由是，网卡负载太高时有些包连网卡都没收到，根本不可能来得及汇报给内核。另外，如果是路由器把udp丢了，那udp的目的端机器当然更不可能感知到有丢包了。

这时，同事说netstat -us (–statistic)可以看到udp的丢包。这里的u选项指的是只展示udp相关的统计，s选项自然表示的是统计了。如果不用u选项，则出显示所有统计数据。下面是我的机器上的输出。

Ip:
    203440255187 total packets received
    0 forwarded
    0 incoming packets discarded
    201612429535 incoming packets delivered
    1064529177 requests sent out
    15 fragments dropped after timeout
    3058122492 reassemblies required
    1230296840 packets reassembled ok
    15 packet reassembles failed
Icmp:
    14869220 ICMP messages received
    3965512 input ICMP message failed.
    ICMP input histogram:
        destination unreachable: 6054246
        timeout in transit: 687
        echo requests: 8570532
        echo replies: 243755
    12913011 ICMP messages sent
    0 ICMP messages failed
    ICMP output histogram:
        destination unreachable: 4097869
        time exceeded: 5
        echo request: 244605
        echo replies: 8570532
IcmpMsg:
        InType0: 243755
        InType3: 6054246
        InType8: 8570532
        InType11: 687
        OutType0: 8570532
        OutType3: 4097869
        OutType8: 244605
        OutType11: 5
Tcp:
    111681768 active connections openings
    4186820 passive connection openings
    24951865 failed connection attempts
    55064041 connection resets received
    275 connections established
    1033901799 segments received
    1776166765 segments send out
    12156205 segments retransmited
    6705 bad segments received.
    106348033 resets sent
Udp:
    198894689917 packets received
    472986510 packets to unknown port received.
    1146976531 packet receive errors
    116750744 packets sent
    110301286 receive buffer errors
    0 send buffer errors
UdpLite:
TcpExt:
    423 invalid SYN cookies received
    693 packets pruned from receive queue because of socket buffer overrun
    19 packets pruned from receive queue
    11309370 TCP sockets finished time wait in fast timer
    106 packets rejects in established connections because of timestamp
    10210477 delayed acks sent
    20811 delayed acks further delayed because of locked socket
    Quick ack mode was activated 8856 times
    17118697 packets directly queued to recvmsg prequeue.
    301717551 bytes directly in process context from backlog
    152118951904 bytes directly received in process context from prequeue
    104771733 packet headers predicted
    15179703 packets header predicted and directly queued to user
    218747377 acknowledgments not containing data payload received
    102637644 predicted acknowledgments
    7293 times recovered from packet loss by selective acknowledgements
    Detected reordering 40 times using FACK
    Detected reordering 27 times using SACK
    Detected reordering 1088 times using time stamp
    476 congestion windows fully recovered without slow start
    5287 congestion windows partially recovered using Hoe heuristic
    236 congestion windows recovered without slow start by DSACK
    151673 congestion windows recovered without slow start after partial ack
    1 timeouts after reno fast retransmit
    4 timeouts after SACK recovery
    10540 timeouts in loss state
    7232 fast retransmits
    649 forward retransmits
    1871 retransmits in slow start
    11612658 other TCP timeouts
    TCPLossProbes: 93185
    TCPLossProbeRecovery: 14667
    2431 packets collapsed in receive queue due to low socket buffer
    8814 DSACKs sent for old packets
    3350 DSACKs received
    1 DSACKs for out of order packets received
    90851 connections reset due to unexpected data
    214 connections reset due to early user close
    352 connections aborted due to timeout
    TCPDSACKIgnoredNoUndo: 1571
    TCPSpuriousRTOs: 7
    TCPSackShifted: 94
    TCPSackMerged: 131
    TCPSackShiftFallback: 21183
    TCPTimeWaitOverflow: 1876775
    TCPRcvCoalesce: 15711184
    TCPOFOQueue: 3194
    TCPChallengeACK: 2337394
    TCPSYNChallenge: 13608
    TCPSpuriousRtxHostQueues: 1982796
IpExt:
    InBcastPkts: 46443933
    InOctets: 44312451521655
    OutOctets: 1915626725817
    InBcastOctets: 6827280595

喂，要是转载文章。麻烦贴一下出处 ykyi.net 采集爬虫把链接也抓走

Linux系统级/进程级最多打开文件数,FD文件描述符数

Thu, 22 Nov 2018 11:55:39 +0000

如何增加Linux系统最大文件打开数目呢？

查看系统最大可打开文件数

以下命令查看操作系统级最多可打开文件数,fd数目

$ cat /proc/sys/fs/file-max

我用ubuntu 16输出:

怎么调整系统最大可打开文件数

# sysctl -w fs.file-max=1000000

需要用root用户执行以上命令，设最大为一百万。
但在命令行上修改了这个配置，会在下一次操作系统重启后重置为以前的值。要一劳永逸的改变系统最大打开文件数，需要修改 /etc/sysctl.conf 文件。

fs.file-max = 1000000

在/etc/sysctl.conf文件中增加上述一行。

ulimit命令查看/调整进程级最大文件打开数

$ ulimit -Sn
1024

这个命令查看一个ulimit的软极限值(soft limit)，本用户起的进程的最大文件打开数的限制。我的ubuntu 16显示进程最多开1024个fd。如果要提高每个进程可同时打开的文件数，需要更改这个值。

$ ulimit -Sn 2048
bash: ulimit: open files: cannot modify limit: Invalid argument

但我想把每个进程可同时打开的文件数增加到以前的两倍时，报错了。这是因为，软极限值(soft limit)不能够越过(Hard Limit)。我看了一下Hard limit，也是1024

$ ulimit -Hn
1024

那没办法罗，需要以root用户登录更改Hard Limit。

怎么修改普通用户的硬极限hard Limit

用root账户登录后，编辑 /etc/security/limits.conf文件，假如普通用户名是kamuszhou。

kamuszhou hard nofile 10000
kamuszhou soft nofile 5000

以上配置修改kamuszhou普通用户的最多打开文件数的hard limit为10000，soft limit为5000。
对于ubuntu 16，如果使用图形桌面，还需要修改 /etc/systemd/system.conf 和 /etc/systemd/user.conf。
加上这么一行：

如何定制一个python的logging Handler

Tue, 20 Nov 2018 11:16:45 +0000

上个月用python的gevent协程库写了一个tcp服务。日志库使用python标准日志库logging。一个月后，发现一个偶发的bug。这个bug发生时，用python的标准日志库自带的FileHandler写的日志会发往socket占用的文件描述符fd。结果就是，客户端收到了本要打印到磁盘上的日志。花了不少时间定位排查这个bug，仍然没有结果。我开始怀疑是gevent协程库和python的标准日志库logging有冲突。协程库会错误的把logging打开的文件描述符fd关闭并分配给新创建的socket，于是日志就打印到socket占用的fd了。

后来，写了一个检测脚本用来监控这个情况发生的概率。该脚本每分钟会检查进程占用的所有fd，一但发现用来打印本地日志的文件fd不见了，就重启服务进程。核心代码如下:

lsof -p $pid | grep -q ${log_file_name}
if [ $? != 0 ]
then
    # 报警代码 ...
fi

发现bug发生的频率大概是一个星期一次。但这毕竟根本上解决不了问题啊，又找不到bug的原因，怎么办？

那就自定义一个File Handler吧！

决定自定义一个File Handler，这个File Handler工作在另外一个单独的进程，这样无论如何日志用的fd都不会跟主进程的各种socket用的fd冲突了吧。
代码如下，主要用到的技术进程通讯和用python的__getattribute__魔法把截获类实例的方法调用。这样，只需要把旧的代码中的File Handler(我用了TimedRotatingFileHandler)换成自定义的Handler Class，所有其他旧代码都无需改动。

#!/usr/bin/env python3

'''
created by kamuszhou*AT*tencent.com, zausiu*AT*gmail.com http://ykyi.net
Nov 20, 2018
'''

import logging
import logging.handlers
from functools import partial
from multiprocessing import Process, Queue


class MySpecialHandler(logging.StreamHandler):
    def __init__(self, *args, **kargs):
        self._q = Queue()
        self._p = Process(target=MySpecialHandler.__run, args=(self._q,))
        self._p.start()
        self._q.put(('__init__', args, kargs))

    def join(self):
        self._p.join()

    def __run(q):
        handler = None
        while True:
            # op, params = q.get()
            method, args, kwargs = q.get()
            if method == '__init__':
                handler = logging.handlers.TimedRotatingFileHandler(*args, **kwargs)
            else:  # 主进程的日志调用实际上被转到这里
                getattr(handler, method)(*args, **kwargs)

    def __proxy(self, name, *args, **kwargs):
        # 把调用的方法名和方法参数通过Queue传到专门的日志进程。
        self._q.put((name, args, kwargs))
        fun = logging.StreamHandler.__getattribute__(self, name)
        # print('call method: ', name, args, kwargs)
        # 如果是setLevel函数，再调用一次父类的方法
        if name in {'setLevel'}:
            return fun(*args, **kwargs)

    def __getattribute__(self, name):
        '''
        Hook大法！截获所有方法
        '''
        attr = logging.StreamHandler.__getattribute__(self, name)
        if hasattr(attr, '__call__') and name not in {'join', 'emit'}:
            return partial(MySpecialHandler.__proxy, self, name)
        else:
            return attr


if __name__ == '__main__':
    handler = MySpecialHandler('/data/tmp/ttt.log', when='D', interval=1, backupCount=90)
    handler.setLevel(logging.DEBUG)
    formatter = logging.Formatter('%(asctime)s: %(levelname)s %(message)s')
    handler.setFormatter(formatter)
    logger = logging.getLogger(__name__)
    logger.propagate = False  # Don't propagate the logging to ROOT
    logger.setLevel(logging.DEBUG)
    logger.addHandler(handler)
    logger.debug('debug testtttttttt')
    logger.info('info testtttttttttt')
    logger.warn('warn testtttttttttt')
    logger.error('error testtttttttt')
    logger.critical('critical testttttt')
    handler.join()

这里自定义的日志进程类只是一个很粗糙的实现，一但跑起来，只能手动杀进程。反正我的使用场景是一个服务。所以，我也懒得加‘优雅的退出代码’。

伯努利(Binomial)分布和伯努利试验的区别，负伯努利分布及几何分布,超几何分布

Tue, 13 Nov 2018 11:49:15 +0000

[mathjax]我又重新把概率，统计书拿起来了。这次是真的，要把机器学习（统计学习)学好。显然，学好机器学习并不是一件容易的事情。需要要扎实的数学基础。好在我的数学储备还勉强可以，但远算不上“基础扎实”。所以，我有了一个长期远景规划，重新开始学习吧！

今天看了伯努力分布，负伯努利分布，超几何分布，几何分布这几个知识点。下面我一边写回顾今天学到的，一边写文章。

伯努利分布和伯努利试验的区别

伯努利试验(Binomial Experiment)指的仅仅是”一次试验”，或者成功，或者失败。伯奴利分布是一个常用分布，这是完全不同的两个概念。
每次伯努利试验的成功概率记为p，又把重复很多次伯努利试验称为伯努利过程(Binomial Process)。一个重复了n次伯努利试验的伯努利过程中，成功的试验次数记为X，这个X则是伯努利随机变量。X的概率分布被称为伯努利分布。
伯努利分布：

$$b(x;n,p) = {n \choose x} p^k (1-p)^{ n-k}$$

其中，n表示试验次数，p表示每次独立试验成功的概率，x表示成功次数。

什么是负伯努利分布(Negative Binomial Distribution)

伯努利分布和负伯努利分布的大多数设定都是一样的，都不断重复伯努利试验，要么成功要么失败。
不同点是：伯努利分布的随机变量X，表示的是在前n次伯努利试验中成功了x次；而负伯努利的随机变量x，表示的是要达成k次成功试验，需要试验x次（即第x次试验成功，前x-1次试验成功了k-1次）。伯努利分布限定了试验次数记为n，负伯努利限定了成功次数记为k。
负伯努利分布：

$$b^*(x;k, p) = {{x-1} \choose {k-1}}p^kq^x-k$$

几何分布和超几何分布

再以伯努利分布为讨论的基础，仅更改一处，即把伯努利过程中的放回抽样(with replacement)改成不放回抽样(without replacement)，即可得到超几何分布。
以负伯努利分布为讨论的基础，仅更改一处，即k设为1，表示成功一次。即不断重复伯努利试验，直到第一次成功就结束，得到了几何分布。

伯努利分布，负伯努利分布的命名

为什么叫伯努利分布
因为伯努利展开式$$(q+p)^n$$的n+1个项对应伯努利分布取各个值时的情况。
为什么叫负伯努利分布
因为展开式$$p^k(1-p)^(-k)$$中的每个项对应$$b^*(x;k,p)$$取x=k, k+1, k+2, …时的情况。

安装MathJax-LaTeX插件，让wordpress显示数学公式

Tue, 13 Nov 2018 09:14:27 +0000

最近看统计学，涉及很多数学公式。于是，想找到一款wordpress的插件可以显示数学公司。

当然，于是就找到了 MathJax-LaTex这个插件。虽然插件名字中有LaTex，但实际上不仅仅可以用LaTex语法描述数学公式，亦可用AsciiMath，以及MathML。
本以为像其它所有wordpress插件一样，安装很简单，很容易就能上手使用。没想到还是花了一些时间。

MathJax-LaTex插件依赖MathJax这个javascript开源工程。原因貌似是MathJax默认用的CDN在大陆被墙了，还是因为浏览器的同源策略被浏览器禁了??我懒得重现排查真正原因了。总之，我用MathJax-LaTex默认配置没有成功，于是我自己手动下载并安装到自己的服务器，运行OK。

首先到 https://github.com/mathjax/MathJax{.wp-editor-md-post-content-link} 下载源代码。熟悉git的同学可以用git下载，亦可用右边的 Clone or Dowload 按钮下载zip包。
把zip包上传到自己的服务器，找一个目录解压缩。
打开MathJax-LaTex的配置web页面，如下图如示，去掉Use MathJax CDN Service 的勾，不要用MathJax自己的CDN；然后，在Custom MathJax location选项中填上自己的路径。假如刚才zip包MathJax解压缩到的目录是/tools，那么就填上 /tools/MathJax-2.7.5/MathJax.js 。
{.wp-editor-md-post-content-link}
然后创建一篇新博文，现在可以录入数学公式啦。装逼必备！比如下面的伯努利分布的公式： [mathjax]

$$b(x;n,p) = {n \choose x} p^k (1-p)^{ n-x}$$

要输入上述方程式，在文章开头输入**[mathJax]** ,这个标志让MathJax-LaTex插件加载显示数学公式相关的javascript代码。然后敲两个美元号 $$，敲入公式 b(x;n,p) = {n \choose k} p^k (1-p)^{ n-k}，再敲入两个美元号结尾。即用双美元号$$把公式围起来。亦可用[latex][/latex]这对标签把公式围起来。这对标签这里的公式描述用了 asciiMath语法. n choose k即一个组合。在网上搜索相关语法参考。

在这个页面可以看到更多用MathJax显示的数学公式的例子，用浏览器的查看源代码功能(ctrl-u)查看使用的语法：
使用LaTex语法： http://ykyi.net/zausiu/MathJax-2.7.5/test/sample.html{.wp-editor-md-post-content-link}
使用AsciiMath语法： http://ykyi.net/zausiu/MathJax-2.7.5/test/sample-asciimath.html{.wp-editor-md-post-content-link}
使用MathML语法：http://ykyi.net/zausiu/MathJax-2.7.5/test/sample-mml.html{.wp-editor-md-post-content-link}

C/C++用万恶的libcurl透过HTTPS发POST+JSON请求

Thu, 21 Jun 2018 02:22:04 +0000

相比python, nodejs这样的脚本开发语言已有非常好用的RESTful开发库，很多C/C++程序在调用RESTful接口时，还在使用非常难使用的libcurl纯C接口。下面是用libcurl透过HTTPS发POST请求的代码代段，http body是json字符串：

    #include <curl/curl.h>

    CURL* curl;
    struct curl_slist* headers;
    curl = curl_easy_init();
    headers_ = curl_slist_append(headers, "Content-Type: application/json");
    curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
    curl_easy_setopt(curl, CURLOPT_SSLCERTTYPE, "PEM");
    curl_easy_setopt(curl, CURLOPT_SSLCERT, cert_file_path.c_str());
    curl_easy_setopt(curl, CURLOPT_SSLKEYTYPE, "PEM");
    curl_easy_setopt(curl, CURLOPT_SSLKEY, key_file_path.c_str());
    curl_easy_setopt(curl, CURLOPT_CAINFO, ca_file_path.c_str());
    curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 1L);
    curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, -1L);

    // jv_text存了json字符串
    curl_easy_setopt(curl_, CURLOPT_POSTFIELDS, jv_text.c_str());
    curl_easy_setopt(curl_, CURLOPT_URL, path.c_str());

    CURLcode res = curl_easy_perform(curl_);
    if (res != CURLE_OK)   // 没有成功
    {
        LG_ERR("curl_easy_perform() failed: %s", curl_easy_strerror(res));
    }
    else  // 成功了
    {
    }
    curl_easy_cleanup(curl);

openssl签发证书肘后备急方（cheatsheet）

Wed, 20 Jun 2018 07:03:11 +0000

生成一对新的RSA非对称密钥,2048bits长。 generate an RSA private key

openssl genrsa -out private.key 2048

从私钥中提出公钥。 extract the public key

openssl rsa -in mykey.pem -pubout > my_pubkey.pub

创建自签名证书。create a self-singned certificate

openssl req -config openssl.conf -x509 -sha256 -days 3650 -newkey rsa:4096 -keyout ca.key -out ca.crt

签署CSR。sign the CSR

openssl ca -config openssl.conf -days 375 -notext -in test.csr -out test.crt

检验签书。verify the certificate

openssl verify -CAfile ca.crt test.crt

生成一个CSR。Generate a new private key and CSR(Certificate Signing Request)

openssl req -config openssl.conf -out CSR.csr -nodes -new -newkey rsa:2048 -nodes -keyout private.key

nginx架设HTTP服务器接受PUT方法上传文件

Tue, 27 Mar 2018 08:46:21 +0000

最近用nginx架了个http服务器，通过http上传文件。
nginx的配置如下：

        location ~ ^/wraith {
            root /data/tmp;
            dav_methods PUT;
            dav_access user:r group:r all:r;
            create_full_put_path on;

            limit_except GET {
            }
        }

如上，子目录/wraith将接受PUT方法。

$curl -XPUT --data-binary @${TAR_PATH} --noproxy '*'  http://xxx.xxx.xxx.xxx/wraith/${TAR_FILE}

如上用curl通过http上传文件到服务器的/data/tmp目录下，文件命名为${TAR_FILE}

utf8中文字符串的多模式匹配算法的优化

Mon, 20 Nov 2017 08:44:25 +0000

utf8中文字符串的多模式匹配算法的优化

信息安全部接口组 kamuszhou@tencent.com

效果

本节仅展示优化效果，对一些业务逻辑和背景未做解释，读者可直接跳至下一节。
上个月接触到了我组的一个关于在海量文本中匹配字符串业务。读源代码时发现一些问题，并针对这些问题做了优化工作，效果非常明显。

测试的硬件环境是只用一颗主频2.4G的Intel至强处理器核心。OS是tlinux2。该业务目前载入11万3千条规则。优化前后的效果如下：

|载入 | 旧算法 |旧算法简版| 新算法 | 提升效果 |
|:—:|:——:|:——–:|:——-:|:——-:|
|速度 | 26分钟 | 3分钟 | 3秒 |60倍或250倍|
|内存 | 4327M | 4327M | 不到200M| 20倍 |

表中的“旧算法简版”指去掉了一个繁琐的预计算步骤

|处理速度 | 旧算法 | 新算法 | 提升效果 |
|:—:|:——:|:——–:|:——-:|
|用11万3千条规则作为待检测文本|52秒|2秒|26倍|
|10倍四大名著共88M,平均每行143个汉字|59秒|10秒|近6倍|
|文字选自四大名著共87M,平均每行10个汉字|161秒|5秒|32倍|

用11万3千条规则作为待检测文本使得新旧算法都会密集地走到“命中逻辑”，旨在比较“命中逻辑”的性能。
用四大名著作为待检测文本，使得新旧算法几乎不会走到“命中逻辑”，旨在比较算法处理正常文本时的性能。而每次处理文本的长度亦可能影响到性能表现。如表所示，处理短文本（10个汉字）时，新算法的优势有所降低，可解释为旧算法为启动每一次处理消耗较大的资源，而如果处理的文本较长时，这个资源消耗分摊到每个待处理字符就相对不那么明显了。

在一台24核的M2机器上，理论估计新算法一天可以处理36,495,360M文本，36个T~

业务简述

该业务的核心问题简单地近似概括为：

有几十万甚至更多的模式(短字符串)集合P={P1, P2, …, Pn}，输入一个utf8编码的字符串string，输出有哪些模式Px在string中出现。

实际问题比上面的描述稍微复杂一点点。业务需要通过找到的模式判断是否命中预定的规则。一个模式串或多个模式都可以组成规则。比如，单独的一个Px组成一条规则，多个不同的模式则会组合成一个与关系的规则（目前业务只支持与关系，支持更复杂的匹配规则是将来需要增强的地方）。比如，有下面几条规则：

铁王座
雪诺 & 提利昂
雪诺 & 艾莉亚 & 2
雪诺 & 龙母 & 床
雪诺 & 夜王 & 异鬼军团 & 守夜人

下文的讨论将继续引用这个规则列表。

服务器端的tcp有大量TIME_WAIT怎么办

Fri, 20 Oct 2017 06:03:06 +0000

公司的群里讨论tcp的TIME_WAIT的问题。TIME_WAIT这个状态可是面试时经常问的知识点啊。
讨论的问题是：有一个服务器，它对外网提供服务，同时它作为客户端连接很多后端的其它服务器。这位同事连后端其它服务器时用了短tcp连接。结果出现了大量的tcp TIME_WAIT状态，吞吐量上不去，怎么办？

先说结论：

如果该服务器要处理外网IP的入流量，那最好的办法应该是用tcp长链接改造它与后端服务器的连接。如果用中间件，比如上zeromq那更省心了。
如果不想做改动，并且在应用层确认已经交互已经完成，则可以用shutdown()直接发RST结束tcp会话，而不走正常的4次挥手。查阅shutdown系统调用的文档获知如何发RST。
如果该服务器不需要处理处网IP请求的话，那么，启用port reuse 即打开net.ipv4.tcp_tw_reuse不会有太大问题(如果处理外网请求就有问题，和NAT相关，见https://vincent.bernat.im/en/blog/2014-tcp-time-wait-state-linux)，或者更好的，把/proc/sys/net/ipv4/tcp_fin_timeout改小，改成1或者2。让TIME_WAIT只保持很短的时间。

首先，需要知道一个tcp会话由 src_ip, src_port, dest_ip, dest_port 四元组确定。
我们公司的IDC环境中，上述的服务器作为客户端再发起tcp连接联后端服务器，则 src_ip 固定了， dest_ip是后端服务器的ip, port是后端服务器监听端口。这样只有 src_port 是可变化的，但port只有16个bits还不能用well-known ports，这样就更少了。

再说，主动关闭时，tcp连接需要进入TIME_WAIT状态，保持两倍MSL时长，是为了处理两种情况：

让当前这个会话的迷路包在网路中消失。这样不会干扰到新建的会话。
确保主动关闭方的FIN-ACK包，如果丢失的话，还能重发。
1981年的TCP RFC上把MSL设成两分钟，https://tools.ietf.org/html/rfc793

Maximum Segment Lifetime, the time a TCP segment can exist in
the internetwork system. Arbitrarily defined to be 2 minutes.

MSL设置这么长，因为以前的网络环境差啊。不过现在因为移动互联网，比较差的网络状态也是非常常见的。但RFC允许实现方减少MSL值。事实上linux的MSL写死在代码中为1分钟并且不可在运行期配置。
如果tcp连接的双方都在性能高速稳定的内网中，这个MSL就太长了。

调试时，还发现如果port用完了，connect的时候内核代码会用自旋锁忙等检查port资源。有linux内核开发基础的开发者都知道spin_lock的时候是不会让出cpu的，于是cpu全被spin_lock吃掉了。一直要等到有port被释放。再后来又发现，如果scoket没有设定SO_REUSEADDR选项，则connect()系统调用会返回EADDRINUSE。

tcp的连接双方都是确定且长期的，用什么tcp短连接呢？？改造吧~~~

用lftp为ftp服务器做镜像

Wed, 27 Sep 2017 11:54:46 +0000

用lftp为ftp服务器做镜像

命令是这样的:

$ lftp -d -u user_name,password ftp_server_host -e "mirror -c -e --parallel=5 / /path/to/mirror"

解释一下这里的选项：

-d 调试模试，看到详细的输出
-u 用户名和密码，用,隔开
-e 让lftp执行lftp自有的一些命令
mirror 执行做镜像命令
-c continue a mirror job if possible 继续做镜像，如果可能的话。难道不用这个选项，做镜像的过程有可能被中断？
-e 如果一个文件在ftp站点上没有，但在本机上有，则删除这个文件
–parallel 并发数
http://ykyi.net
mirror 命令还有一个 -R 参数，这样的话，会put文件到ftp服务器，效果和上例相反。

访问ES最简单示例

Fri, 25 Aug 2017 03:32:09 +0000

这些天架了一个ES集群，用来分析积累了海量日志数据。我用sphinx写了一个简单文档，发布在内网。下面是复制过来的部分内容，不幸的是很多格式信息都丢失了。做了点简单修改，去掉了敏感信息。

///////////////////////////////////////////////////////////

本示例仅示范最为基础的应用，协助读者调通最简单的查询。详细灵活的使用方法非本文档能够覆盖，需参见官方详细文档或咨询你常用的搜索引擎。

使用curl命令行工具
使用es官方python库
1. RESTful接口
2. 官方python库

使用curl命令行工具

NOTICE:

<div class="line">
  [*略去较为敏感的鉴权部分*]
</div>

在访问日志中检索一个keyword，无论keyword出现在哪个字段中。如下示例：所有文档，superuser出现在其中任意字段中都会被召回。注意酌情更换URI中的参数。实际上，把_all替换成user_name，则只在user_name字段中检索。这里使用的是lucene语法，参见：https://lucene.apache.org/core/2_9_4/queryparsersyntax.html

1	curl https://endpoint/_search?q=_all:superuser

使用ES的DSL语法，在访问日志中检索出现在指定字段中的keyword。如下示例：superuser出现在user_name字段中。

curl https://endpoint/_search?pretty -H "Content-Type: application/json" -X POST -d '
{
   "query":{
       "bool":{
             "filter":[
                 { "term":{ "user_name": "superuser" } }
             ]
       }
   }
}'

上述检索方法使用了ES中的filter语法，filter是较快的一种查询方式。如果需要检索的字段需要分词，则只能使用 match语法，如下：

curl ./kamus.key https://endpoint/_search?pretty -H "Content-Type: application/json" -X POST -d '
{
   "query":{
       "match":{
             {"user_name": "superuser"}
       }
   }
}'

为检索增加时间限制如需要指定时间区间：

curl "https://endpoint/_search?pretty" -d '
{
  "query":{
       "bool":{
               "must":{
                    "match":{
                                "user_name":"superuser"
                            }
               },
               "filter":{
                     "range":{
                          "req_time":{
                                        "gte":"2017-01-01 00:00:00",
                                        "lt":"2017-08-08 00:00:00"
                                     }
                       }
                }
        }
  }
} '

分页 ES的分页使用”from”和”size”参数。例如，每页10条，返回第1页。

curl "https://endpoint/_search?pretty"  -d '
{
     "from": 0,
     "size": 10,
     "query": {
         "term": {
              "user_name": "superuser"
         }
     }
}
'

由于ES的实现机制，ES并不鼓励使用分页，在size较大且from的页码也较大时，ES可能无法及时响应。

如果需要返回所有命中文档如果命中文档超过一千，用上述方法不容易拿到所有结果。需要使用 scroll and scan 方法。参见 https://www.elastic.co/guide/en/elasticsearch/reference/current/search-request-scroll.html

其他高级应用如bool操作，以及复杂灵活的查询条件组合请参加官网文档。

It’s not lupus 是个什么梗，什么意思呢

Thu, 03 Aug 2017 03:08:55 +0000

著名黑客于旸, AKA tkyu, tk教主在论坛里的头像是一个狰狞面孔的人，头像下面有一行英文：

It’s not Lupus

这句话是什么意思呢？原来来自2007年福克斯Fox的一部电视连续剧 House。
剧中主人公是普林斯敦大学教学医院的医学天才(Dr. House)，他反传统并且不愿意与人交往。他的工作伙伴是一些年轻的医生。
年轻的医生在搞不清楚病人发病原因的时候，就认为这可能是Lupus(狼疮)。因为Lupus这个病需要好几年才能够被确诊。这时，Dr House就说： “It’s not lupus”或“It’s never lupus”。直到有一天，确实出现了一个Lupus案例。
我猜，tk教主引用_It’s not Lupus_这句话可能暗指他也是Dr House一样的天才吧~

发现linux命令/工具find的一个”bug”

Wed, 02 Aug 2017 08:02:19 +0000

今天用find命令找一个目录下面所有大小小于1K的普通文件. 我的命令是这么写的：

$ find ~ -type f -a -size -1K | wc -l

发现得到的数字明显比预想的小很多。但命令没错呀~~百思不得其解之下，又试了一下另一种写法。这时，就正常了，真奇怪啊~~

$ find ~ -type f -a -size -1024c | wc -l

这次就正常了！！！
我反复查文档：

c for bytes
K for Kilobytes (units of 1024 bytes)

对啊~~没错啊。 1K就是1024byte。哪里出问题了，哪出出错了呢？难道是linux的bug吗？我换了一个发行版的linux，发现还是同样的情况。这就郁闷了~~
再次查看文档，这次详细读文档了！终于发现问题所在了：

The + and – prefixes signify greater than and less than, as usual. Bear in mind that the size is rounded up to the next
unit. Therefore -size -1M is not equivalent to -size -1048576c. The former only matches empty files, the latter matches
files from 1 to 1,048,575 bytes.

读吴军的”硅谷来信：第230封为什么中国不会掉入中等收入陷阱”之疑惑

Sun, 04 Jun 2017 04:58:25 +0000

吴军是我很佩服的一位科学家兼科技作家。他的学误之渊博，让人惊叹。

最近，我看了吴军大神的”硅谷来信：第230封为什么中国不会掉入中等收入陷阱”。这篇文章分上，下两篇。下篇的末段部分提到一个针对“缩小国有企业规模”的观点，原文如下：

缩小国有企业规模。这件事不需要做，虽然中国的国有企业相比一些明星私营企业显得效率低一些，但是人均产值依然
高过私营企业的平均水平。更重要的是，国有企业是目前中国经济走向世界的排头兵，因为它们可以不计成本地向海外扩张。
相比之下，中国私营企业除了华为、联想等少数企业，大部分私营老板是舍不得自己掏腰包，对走
向世界进行长期大规模投资的。所谓的BAT（百度、阿里巴巴、腾讯）虽然自己挣钱不少，但依然
是窝里横的公司，而且直到今天也没有认认真真做国际化的事情。这些公司尚且指望不上，何况其它私营企业了。

这段话有相当多的问题：

国企人均产值依然高过私营企业平均水平。

注意，这里是人均产值，不是企业效率。国有企业垄断占据了几乎所有赚钱的行业：烟草，金融，能源，电信，人均产值能不高吗？但如果比生产效率呢？

国企可以不计成本地向海外扩张。

“不计成本”地扩张？？成本100美元，卖10美元？？？不计成本是好事吗？民营企业卖扣子卖眼镜卖衬衣卖打火机辛苦积累的外汇，国企不计成本的挥霍，难道是好事，不应该是国企的缺点吗？

吴军大神认为私营企业不做海外扩张，但吴大神先排除掉华为联想

2000年以后，满世界的made in china的小商品，难道不是私营企业做的？
华为，联想是民企的代表企业，特别是华为，为何华为联想不算数？十五年前，同在深圳的民企华为和国企中兴尚且在同一量级，如今，民企华为的体量可是中兴的十倍之巨还多。
那不说华为，联想。小米，oppo，vivo们在南亚，东南亚把三星打得满地找牙，算不算民企的海外扩张。制造业的“三一重工”算不算私营企业，可搜索新闻“三一重工强攻新兴市场，海外收入占比升至50%”，这还是三年前，2014年的数据。
大疆几乎吃下了全世界民用无人机市场，算不算海外扩张么。
再说一家小而美的互联网公司，猎豹移动，这家公司的海外营收可超过了70%。
还有当下火热的共享单车。ofo,mobike们刚起步就已经把业务扩张到了北美和欧洲。
中小型公司里积极开拓海外市场的并不在少数吧。吴大神装做不知道？

况且该文的中段有提到

你只能看到中国的商人去拉美国家上门买酒，看不见他们的商人到中国推销酒。

又有：

中国的商人往返于世界各地，积极开拓海外市场。

这里提到的中国商人不多是民营企业家吗，难道都是国企高官？如果这里的商人多指私营企业家，那作者的观点岂不是前后矛盾。

所谓的BAT（百度、阿里巴巴、腾讯）虽然自己挣钱不少，但依然是窝里横的公司，而且直到今天也没有认认真真做国际化的事情。

互联网先在美国繁荣发展，国内互联网公司的前步较晚。在最初期，BAT们刚刚出生，尚且为了生存，忙于和在华的巨头微软，谷哥，亚马逊，雅虎，ebay激烈竞争。不能苛求国内市场还没占领就海外扩张吧？
那看现在，百度在硅谷成立了AI实验室，腾讯在西雅图微软的大门口也成立AI实验室与微软直接竞争，阿里云在世界范围内力战亚马逊算不算海外扩张？
更不用说BAT的海外资本运作了，腾讯在2000年前就投资了Roit Games开发出世界第一网游LOL，去年收购super cell，今年入股tesla，算不算海外扩张？BAT的海外投资比比皆是。

BAT尚且指望不上，何况其它私企

退一万步，假设BAT确实没有任何出海商业活动，“何况其它私企”这句话的逻辑在哪？BAT只能代表互联网行业，而私营企业长满了国内每个允许民资进入的行业。BAT能代表他们吗？

我想，一定是因为吴军高贵的谷歌血统，狗眼看人低。和谷歌比，国内的民营企业家们，都是泥腿子，吴军就是看不起你！

我理解的区块链技术

Tue, 16 May 2017 12:01:10 +0000

同事叫我写点对区块链的看法。我大概在四年前比特币火热的时候看了一些相关的资料，就随便写一点吧。

Blockchain Technology

什么是区块链

区块链技术最早可追述到1991年 by Stuart Haber & W. Scott Stornetta.
以2008年Satoshi Nakamoto对区块链技术的阐述及第二年2009年创建了比特币
标志了区域链技术的成熟。
维基百科给出的定义是:

A distributed database that maintains a continuously growing
list of records, called blocks, secured from tampering and revision.

区块链是一个分布式的数据库。它的数据被组织成不断增长的记录链表。
其中记录被称为“区块”。区块被加密，保证不被篡改。

以BitCoin举例:
比特币是一个巨大的分布式的记账系统，该分布式系统的每一个结点都记录了在
比特币网络上发生的每一笔交易。如果要篡改数据，除非能控制这个网络上的绝
大部分结点并且同时修改这些结点的相关加密数据。

关键技术

区块链技术最大的创新即在一个去中心化的系统中解决了数字货币的Double Spending
的问题。

更一般地讲：

区域链技术使用去中心化网络解决了之前需要中心服务器的计账问题

What is Double Spending

如果我们用实物货币交易，交易的任何一方不能同时拥有商品和实物货币。但数字货币
却是可以通过非常廉价地复制获得。在区块链技术出现之前，解决这个问题都是用一个
中心机构解决。交易参与方无条件信任这个中心机构，由它判断并决定某个数字货币的归属。
显然这里有一个单点故障的潜在危险。

使用常景

最大的使用常景还是金融领域，比如数字货币和银行间的清算系统。
对于任何涉及信任，计账，审计，防篡改的系统，都可以用区块链技术提供一个去中心的
实现，而不是传统地信任一个中心机构的解决方案。
比如一个基于区块链技术的全民投票系统。

未来发展

据埃森哲的数据，2016年区域链技术在金融的项目中领域获得了13.5%的采用率，进入初期采用
阶段，于2018-2024年进入快速增长阶段，2025年进入成熟期。
The future of blockchain in 8 charts

在我看来，区块链技术只在金融领域有很大的发展前景，而在其它领域则没有什么优势。理由是，区块链技术的一个重要假设是：不能信任一个权威的中心服务方。但在大多数场景中，引入一个权威的中心服务方是可以接受的有时还是必须的，且开发难度要低。

如何战胜抑郁症

Tue, 16 May 2017 11:43:43 +0000

一篇关于抑郁症的建议：

我的抑郁症持续了比较长的时间，大概从2007年到2014年之间断断续续发作。
最终在2014年年初慢慢走出来。现在几乎不失眠了。
我在发病期间看了非常多的资料，找很多人聊天。思考怎么治好这该死的病。
据我了解，现代医学对抑郁症的发病原因还没有研究得很透，认为非常非常多的因素都会造成抑郁症包括遗传。对病理的研究更是很肤浅，毕竟现代科学对大脑的工作方式还是知之甚少的。但各药厂生产了很多抗抑郁的药物，这些药物的效果因人而异。但基本上都不大可能单靠药物就能治好的。如果没能确定病因，没解决掉源头问题，怎么可能治好呢。但要找到病因却不容易，前面有提到，现代医学在这方面的研究还不够。所以，医生的帮助也是有限的。

我的建议是：
1，首先意识到治好这病需要自己付出很多努力，不能依赖其他人比如找到一个神医
2，评估自己以前的处事方式，我以前对自己要求太严格，总是争分夺秒地不停学习。我给自己设了很多假想敌，总想超过他们。我觉得我中学时读书比你们厉害，我怎么能输给你。为了改变自己这个思维方式，我看了一些哲学思辨的书，还包括一点点宗教神学，主要是佛教。我试图让自己站在一个更大更高的视角看自己以前的工作生活思维方式有多少意义。最终我觉得我不应该有太多锋芒，对于整个宇宙来说，面对自然规律时，个人实在太渺小了。
3，认识新朋友，主动社交。不要只认识精英。三教九流的人都去认识，和他们聊天，了解他们的生活和思考方式。精英阶层的思想大多是竞争进取的，如果自己的圈子都是精英，会让自己的思维局限于此，对治疗抑郁症是不利的。我那时租车搬家时就不失时间和面包车司机聊天，了解他们的生活状态，忧虑和幸福。不同阶层人的生活和思维是大不相同的。他们也要生活，他们也有自己的喜怒哀乐，为何自己自认为各方面都强过他们却生活得如此狼狈。我在2013年在网络上认识了一个粤北的农场主，我专门在假期去他的农场住了四五天，感受农场的宁静和那边的村民生活。

Tue, 17 Jan 2017 09:35:16 +0000

1. 前言：

ZeroMq aka zmq是最知名的网络消息中间件之一。使有zmq的开源软件中最知名的莫过于Apache基金会下的Storm。我厂内部使用zmq的有即通的yaaf框架。

ZMQ社区在2013年9月发布了zmq4。zmq4最大的新功能即提供了一套安全机制，其中有IP黑白名单，用户名/密码鉴权，ECC(Elliptic Curve Cryptography)证书鉴权，以及通讯的加密(类似TSL)。

本文主要介绍zmq4.0的安全机制。

2. ECC的故事：

这里的ECC不是我厂历史上的电商事业群，而是椭圆曲线加密算法。ECC据说被NSA(美国安全局)操作，在算法中设置了后门。不过好在不是只有一种椭圆曲线，而是有无数种，不同的曲线有不同的优点和缺点，只是其中由NIST(美国标准和技术研究署)推荐的曲线被怀疑设置了后门。

ZMQ使用的椭圆曲线算法是Curve25519 ,它有开源实现而且没有专利保护。zmq用了长度为256bits的密钥，强度相当于RSA 3072比特的密钥长度。

ECDH(Elliptic Curve Diffie-Hellman)则是一个密钥协商协议。非常简单地讲，当A与B在一个不受信任的网络中通讯前，A和B先生成一对公私钥，并且A和B通过某个完全的渠道事先知道对方的公钥，然后A和B在握手阶段协商出一个双方公知的私钥供加密接下来的通讯。

可以理解成zmq设计了一个专门为自己定制的精简的TLS，更多的理论细节在http://curvezmq.org/page:read-the-docs，

作为一个码农，下面用代码介绍使用zmq4的Curve安全机制

3. 证书鉴权,通讯加密,IP 白名单

编译zmq4.x以后，会生成一个名叫curve_keygen的程序，用它可以生成zmq 的证书。证书是一个一般的文本文件，如下是一个curve_keygen生成的zmq证书的例子。

# **** Generated on 2017-01-02 14:24:20 by CZMQ **** # ZeroMQ CURVE **Secret** Certificate # DO NOT PROVIDE THIS FILE TO OTHER USERS nor change its permissions.

metadata email = “kamuszhou@tencent.com” curve public-key = “!Upjrn]2Dk)jQkYREsceBnpgoIL7koE{CVnV1j4D” secret-key = “ZPT#=l/#Rtg:TeLbofh:uPi7#/w(GDZq[0^qPZA1”

原来比特位也有大小端endinness.字节序和比特序的故事

Tue, 13 Sep 2016 11:52:46 +0000

我一直以为大小端endianness只针对字节，不针对比特位。
我一直以为全世界所有的cpu解释bit序都是一样的。

昨天才知道endianness也针对bit。
于是就想不明白了。
因为观察到用 htonl 函数转换endianness后，bit位没有变化，只有字节顺序改了呀。

于是google呀，找到这篇好文：

http://www.linuxjournal.com/article/6788?page=0,0

“Byte and Bit Order Dissection”(字节序和比特序深入剖析)

看了这篇文章，才知道 bit序的翻转是由硬件完成的。原来以前这方面很多概念都没理解对。

apt-get通过http代理连接网络

Tue, 22 Sep 2015 03:17:41 +0000

编辑/etc/apt/apt.conf加入下面这行:

Acquire::http::Proxy “http://web-proxy.oa.com:8080”;
按照你的http服务器的地址做相应修改

HTTP2简单教程

Fri, 03 Apr 2015 08:22:39 +0000

译自：http://qnimate.com/post-series/http2-complete-tutorial/

HTTP1.1是在1999年的时候被引入业界的。从当时到现在，WEB已经发生了相当大的变化。很多人开始用移动设备上网，有些移动环境下网络质量非常不稳定。另外，WEB页面的内容也相当的丰富了。这些都负面影响了WEB页面的加载时间。因此，需要一个新的协议来加速WEB的加载。

HTTP/2和SPDY****的区别：

SPDY是谷歌于2009年创造的协议，旨在WEB延迟以及增强安全性。

HTTP/2是SPDY的一个克隆。谷歌已经停止了继续开发SPDY，并且把工作转移到了HTTP/2上来。

HTTP/2****的目标：

减少加载延时。
减少TCP连接数。
增强的网络安全。
保持和HTTP/1.1的兼容。

HTTP/2****的功能：

多路复用Multiplexing：很多个异步的HTTP请求只使用一个TCP的连接。
服务端PUSH：对于一个请求可能有多个回复。
头部压缩：压缩头部(headers)。
请求分级：对同一个域名的请求可作优先级分级。
二进制协议：HTTP/2是一个二进制协议，而HTTP/1.1是一个文本协议。

HTTP/2解决了HTTP/1.1****的哪些问题：

HTTP管道(HTTP pipelining)：一些HTTP1.1客户端使用了HTTP管道技术来减少TCP连接数。HTTP管道指的是多个HTTP请求被发往同一个TCP连接，而不等待前一个请求的回复。但是服务端发送回复时的顺序和收到的请求的顺序一样。因此，造成了HOL阻塞问题(head-of-line blocking)。HOL Blocking简单地说是一个回复的延迟会使得排在它后面的回复都会延迟。HTTP/2透过引用多路复用(Multiplexing)解决了这个问题。多个HTTP请求和多个HTTP回复都使用同一个TCP连续，而且HTTP回复的顺序不需要保持HTTP请求到达的顺序。
同一个域名的多个TCP连接：在使用HTTP/1.1时，需要对同一个域名起多个TCP连接来增加吞吐量。而使用HTTP/2时，对于每个域名，只充许有一个TCP连接（only one TCP connection per domain is allowed）。所有的请求和回复都通过唯一的一个TCP连接进行。
TCP连接的关闭时间：使用HTTP1.1时，一个TCP连接在请求完成时立刻被关闭。但对于HTTP/2，TCP连接能存活相当成地一段时间。
头部压缩：HTTP/1.1是没有头部压缩的，但HTTP/2引入头部压缩进一步的减少了延时。

HTTP/2如何兼容HTT/1?

HTTP/2客户端在不确定对方服务器是否支持HTTP/2时，会用HTTP/1协议向服务器发送请求时带上Upgrade: HTTP/2.0这个头部。如果对方服务器支持HTTP/2，就会回复HTTP1.1 101，表示切换协议(Switching Protocols status)。而对于老旧的服务器则简单地返回HTTP/1.1的状态。

HTTP/2客户端可以记下哪些服务器支持HTTP/2，这样，下次就可以直接发起HTTP/2请求，而不必再经过一个询问和回复(Upgrade Round Trip).

HTTP/2****中的多路复用是怎么回事？

HTTP/2使用多路复用，多个请求和回复全异步的通过同一个TCP连接收发。

HTTP/2是一个二进制的协议。每一个请求和回复都被分配了一个流标志(Stream ID)，而且请求和回复被切成了很多帧(Frame)，属于同一个请求或回复帧的Stream ID相同。因为有了这个Stream ID和Frame的机制，请求和回复可以在服务器和客户程序两端同时全异步的发送。因此，HTTP2没有了Head-of-line Blocking的问题。

每一个Stream还可以被赋于一个优先级，服务器可以分配更多的系统资源处理高优级的Stream。

HTTP/2还有一个传输层级别的流控。它协商了客户程序和服务器两端最多使用多少个Stream,服务器能处理的最大尺寸的Stream以及整个连接最多处理多少字节，以及数据被发送的速率。

HTTP/2中的服务器推送(Server Push)和承诺(Promise)

当服务器“感觉”到客户程序需要更多的资源时，就会给客户程序发送一个Promise Stream ，提醒客户程序需要什么资源。这些stream比一般的stream的优先级要高。

这项技术在加载网页时非常用户，因为网页的大量css和javascrpit可能通过这种方式发送。而HTTP/1的作法是把css和js都combine到一起。

服务器发送Promise Stream时提醒的资源遵守同源策略(same origin policy)

HTTP/2****中的头部压缩：

HTTP/2的头部压缩和HTTP/1.1中早有的用gzip压缩Body不一样。使用HTTP/2时，在客户程序和服务器两端，都会保存一张表，记录了收到过的头部。它们在发送HTTP时不会重复发送一样的头部，当再次发送相同的头部时，只会发送该头部对应的表的索引号。

git小技巧，gitignore只忽略当前目录下的某文件等等

Mon, 28 Jul 2014 08:09:14 +0000

#. 编写git的gitignore文件时如何只忽略当前目录下的某文件呢

在文件名前加斜线 / 即可

# git pull如何从remote中拉下来所有分支

git pull –all

git branch -a 查看目前所有分支，包括tracking branch

再用 git branch –track branch_name start_point 开一个本地分支，并且设好该本地分支的upstream

# git 10小时免输git密码

git config --global credential.helper "cache --timeout=36000"

如果需要清空存下来的密码：

Linux 如何知道有哪些硬件，该装哪个驱动

Wed, 23 Jul 2014 03:12:12 +0000

Linux 如何知道有哪些硬件，该装哪个驱动

公司明文不准安装虚拟机了，被查到就是死罪。于是我在自己的笔记本上安装了Debian Linux。

结果无线网卡识别不了~~

次奥~

怎么破呢？

这么破:

# lspci

该命令列出了所有PCI总线上的硬件设备，稍微看看就能看到自己的无线网卡了。

用boost的方式在预编译期检查编译器和平台以及其它

Wed, 11 Jun 2014 07:38:33 +0000

用boost的方式在预编译期检查编译器和平台以及其它

一般C/C++程序员都知道用一些编译器预编译宏来判断编译器的种类的操作系统。

一般有：
_WIN32 ，不管windows x86 还是 x86_64 都会有_WIN32，注意前面的下划线，如果没有下划线，MSDN的官方定义有这个酷酷的下划线.
__unix__ 是否 unix OS
__linux__ 是否是 linux
__apple__ 是否是平台

原来咧，BOOST库提供了一个相当丰富的库来做这件事：
这个BOOST库是 Predef http://www.boost.org/doc/libs/1_55_0/libs/predef/doc/html/index.html

#include <boost/predef.h>

看看官方文档的目录：
Table of Contents

Introduction
Using the predefs
Adding new predefs
Reference
BOOST_ARCH architecture macros
BOOST_COMP compiler macros
BOOST_LANG language standards macros
BOOST_LIB library macros
BOOST_OS operating system macros
Other macros
Version definition macros
Acknoledgements

包括处理器架构，编译器相关宏，语言相关宏，库相关宏，操作系统相关宏~~~

I like boost ~~~

用Range Adaptor，废弃replace_copy_if之类的函数

Tue, 15 Apr 2014 12:22:48 +0000

看看replace_copy_if的一个简单的例子：

std::vector vec;

boost::replace_copy_if(rng, std::back_inserter(vec), pred, new_value);

对于这种写法，如果使用Range Adaptor的话，则可以写成：

std::vector vec;

boost::push_back(vec, rng | boost::adaptors::replaced_if(pred, new_value));

第二种写法有什么好处呢，

更高效率。因为std::back_inserter有额外的内存分配开销。
更灵活。因为第二种写法可以应用更多的适配器，比如： boost::push_back(vec, rng | boost::adaptors::replaced_if(pred, new_value) | boost::adaptors::reversed);
更安全。因为第二种写法没有用unbounded output iterator。

boost::io_service的poll_one和run_one有什么区别

Tue, 18 Mar 2014 11:03:02 +0000

boost::io_service的poll_one会立即返回(non-blocking)，不管有没有已经被触发的处理函数(ready handler)。

而run_one有可能阻塞。如果还没有被触发的处理函数，run_one会阻塞到有一个handler被调用为止。

更多资料： http://think-async.com/

呃。这篇日志也太短了！！！

BOOST库真是个好东西啊~~好多写法很有现代脚本语言的taste。~~而且，那么丰富的库让生产效率大大提高了。

“右值引用”不是”右值”,而是”左值”

Fri, 21 Feb 2014 05:21:27 +0000

亮瞎你的狗眼了吧~这么拗口。！来补一下C++基础吧~~

右值引用 rvalue reference

右值 rvalue

左值 lvalue

什么是左值 lvalue呢。

本质上，左值是一个可以拿到其地址的表达式。左值lvalue里的l,本质上是locatable的缩写，因为lvalue通常可以放置于表达式的左边，于是就有了左left值的说法。

In C++, an lvalue is an expression whose address can be taken, essentially it’s a locator value.

class MetaData
{
public:
	MetaData (int size, const std::string& name)
		: _name( name )
		, _size( size )
	{}

	// copy constructor
	MetaData (const MetaData& other)
		: _name( other._name )
		, _size( other._size )
	{
		cout << "copy\n";
	}

	// move constructor
	MetaData (MetaData&& other)
		: _name( other._name )
		, _size( other._size )
	{
		cout << "move\n";
	}

	std::string getName () const { return _name; }
	int getSize () const { return _size; }
private:
	std::string _name;
	int _size;
};

class ArrayWrapper
{
public:
	// default constructor produces a moderately sized array
	ArrayWrapper ()
		: _p_vals( new int[ 64 ] )
		, _metadata( 64, "ArrayWrapper" )
	{}

	ArrayWrapper (int n)
		: _p_vals( new int[ n ] )
		, _metadata( n, "ArrayWrapper" )
	{}

	// move constructor
	ArrayWrapper (ArrayWrapper&& other)
		: _p_vals( other._p_vals  )
		, _metadata( move(other._metadata ))
	{
		other._p_vals = NULL;
	}

	// copy constructor
	ArrayWrapper (const ArrayWrapper& other)
		: _p_vals( new int[ other._metadata.getSize() ] )
		, _metadata( other._metadata )
	{
		for ( int i = 0; i < _metadata.getSize(); ++i )
		{
			_p_vals[ i ] = other._p_vals[ i ];
		}
	}
	~ArrayWrapper ()
	{
		delete [] _p_vals;
	}
private:
	int *_p_vals;
	MetaData _metadata;
};

ArrayWrapper get()
{
	ArrayWrapper aw;
	return aw;
}

int main()
{
	ArrayWrapper aw(get());
	return 0;
}

这段代码中的ArrayWrapper的移动构造函数能工作吗？

为什么指针可以做为迭代器使用呢

Fri, 14 Feb 2014 06:47:36 +0000

写了十几年代码了，今天才知道*为什么*指针可以做为迭代器使用。

这是因为：

首先，标准库里有这样一个template，它用来得到特定迭代器的相关特性:

namespace std {
       template <class T>
       struct iterator_traits {
           typedef typename T::value_type            value_type;
           typedef typename T::difference_type       difference_type;
           typedef typename T::iterator_category     iterator_category;
           typedef typename T::pointer               pointer;
           typedef typename T::reference             reference;
       };
   }

而对于指针，又有这样一个模板特例化，

namespace std {
       template <class T>
       struct iterator_traits<T*> {
           typedef T                          value_type;
           typedef ptrdiff_t                  difference_type;
           typedef random_access_iterator_tag iterator_category;
           typedef T*                         pointer;
           typedef T&                         reference;
       };
   }

这个模板特例化的意思是：对于每一个指向类型T的指针，都被定义为一个可随机访问的迭代器。

更详细的，参见文章：介绍iterator_trait http://www.codeproject.com/Articles/36530/An-Introduction-to-Iterator-Traits

C++准标准库boost转向github，并发布模块化boost(modular Boost)

Thu, 13 Feb 2014 12:08:18 +0000

难道是中文社区首次报道吗？我用中文搜索引擎没有搜索到modular boost的文章。

昨天想在STL的map容器上增加一个特性，即把std::map中所有的元素按照加入的先后时间用链表链接起来，以保存元素之间的时序关系。

为了这个基于std::map和std::list的新的容器能够兼容STL的算法，于是想实现stl compatible iterator。一口气读了几十页资料，发现最酷最好的方法是用boost的迭代器模板实现。纠结了很久，最终决定在我的工程中引入boost。为了获得快速开发的好处，还是加入更多的开源库吧。毕竟，如果自己造一个轮子，阅读者仍然要花时间理解你发明的轮子，还不如用已经广泛使用的轮子。况且，计划要引入boost中asio的proactor I/O模型。所以，今天就开始引入boost吧。

于是，发现boost早就发起了modular boost项目并把boost host在github.com上，如下地址：

https://github.com/boostorg

在boost的官方网站上有模块化boost的FAQ:

https://svn.boost.org/trac/boost/wiki/ModCvtFAQ

还有它的简单使用教程：

https://svn.boost.org/trac/boost/wiki/TryModBoost#InstallingModularBoost

教程上说，如果把整个module boost git clone到本地，需要花费45分钟，如果下行网速是3Mbps，而且需要占用1.5G磁盘！

我晕~~

另外FAQ上说：没办法只检出一个子库，暂时不能自动地解决依赖性问题。

原文：

Is it possible to checkout only one library and its prerequisites?

Not automatically. Automatic dependency resolution is planned for the future, but not as a part of the conversion to Git and Modular Boost.

怎么知道gcc搜索头文件的路径

Thu, 13 Feb 2014 08:02:43 +0000

每个C/C++程序员都知道，对于#include directive，一般，以双引号引用的头文件是程序号自定义的头文件。而用尖括号引用的头文件是系统的头文件或其它库文件。

更详细的，编译器先在当前目录找用双引号"“引用的头文件，如果找不到再到系统目录找这个头文件。而对于尖括号引用的头文件，编译器就只在系统文件中搜索了。

那么，到底是在哪些目录中搜索头文件呢？

可以用cpp查看，如下：

root@vicarious:/home/kamus/projs/horoscope/boost# cpp -v
Using built-in specs.
COLLECT_GCC=cpp
Target: x86_64-linux-gnu
Thread model: posix
gcc version 4.7.2 (Debian 4.7.2-5)
COLLECT_GCC_OPTIONS='-E' '-v' '-mtune=generic' '-march=x86-64'
 /usr/lib/gcc/x86_64-linux-gnu/4.7/cc1 -E -quiet -v -imultiarch x86_64-linux-gnu - -mtune=generic -march=x86-64
ignoring nonexistent directory "/usr/local/include/x86_64-linux-gnu"
ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/4.7/../../../../x86_64-linux-gnu/include"
#include "..." search starts here:
#include <...> search starts here:
 /usr/lib/gcc/x86_64-linux-gnu/4.7/include
 /usr/local/include
 /usr/lib/gcc/x86_64-linux-gnu/4.7/include-fixed
 /usr/include/x86_64-linux-gnu
 /usr/include
End of search list.

一般编写makefile时给gcc指定 -I选项，-I的参数代表的目录是搜索系统头文件时使用的目录。可以试试# cpp -I/tmp -v

/tmp目录会被添加为搜索系统头文件时的第一个目录。

如果想要添加搜索双引号"“引用的头文件使用的目录呢，用 -iquote 选项指定更多的目录。

Linux的环境变量LD_DEBUG调试so的加载

Wed, 12 Feb 2014 07:20:25 +0000

一个稍微有经验的Linux程序员都知道使用LD_LIBRARY_PATH 来临时设置加载器搜索动态链接库so的路径顺序。但另一个不为人知的环境变量是LD_DEBUG。这个变量可以提供非常详细的加载动态链接库的信息。

可以把LD_DEBUG设成以下值：

export LD_DEBUG=files # 显示库的依赖性和加载的顺序

export LD_DEBUG=bindings # 符号绑定

export LD_DEBUG=libs # 显示加载器查找库时使用的路径的顺序

export LD_DEBUG=versions # 版本依赖性

export LD_DEBUG=help # LD_DEBUG的帮助信息

试一下把LD_DEBUG设成以上值之一，再随便运行一个程序试试。

一个试验：

root@vicarious:/home/kamus/projs/horoscope/bins# export LD_DEBUG=libs

root@vicarious:/home/kamus/projs/horoscope/bins# vim my.conf

     24360:   find library=libm.so.6 [0]; searching

     24360:   search cache=/etc/ld.so.cache

     24360:     trying file=/lib/x86_64-linux-gnu/libm.so.6

     24360:

     24360:   find library=libtinfo.so.5 [0]; searching

     24360:   search cache=/etc/ld.so.cache

     24360:     trying file=/lib/x86_64-linux-gnu/libtinfo.so.5

     24360:

     24360:   find library=libselinux.so.1 [0]; searching

     24360:   search cache=/etc/ld.so.cache

     24360:     trying file=/lib/x86_64-linux-gnu/libselinux.so.1

     24360:

     24360:   find library=libacl.so.1 [0]; searching

     24360:   search cache=/etc/ld.so.cache

     24360:     trying file=/lib/x86_64-linux-gnu/libacl.so.1

     24360:

     24360:   find library=libgpm.so.2 [0]; searching

     24360:   search cache=/etc/ld.so.cache

     24360:     trying file=/usr/lib/x86_64-linux-gnu/libgpm.so.2

     24360:

     24360:   find library=libc.so.6 [0]; searching

     24360:   search cache=/etc/ld.so.cache

     24360:     trying file=/lib/x86_64-linux-gnu/libc.so.6

     24360:

     24360:   find library=libdl.so.2 [0]; searching

     24360:   search cache=/etc/ld.so.cache

     24360:     trying file=/lib/x86_64-linux-gnu/libdl.so.2

     24360:

     24360:   find library=libattr.so.1 [0]; searching

     24360:   search cache=/etc/ld.so.cache

     24360:     trying file=/lib/x86_64-linux-gnu/libattr.so.1

运行loadlib()提示attempt to call global ‘loadlib’ (a nil value)

Wed, 22 Jan 2014 09:21:49 +0000

2009年的时候用过lua，当时在windows上写金山急救箱的恶意软件库引擎。

时隔多年，又要玩一把lua. 重拾lua，在lua控制台用loadlib载入动态链接库时出错：

> loadlib("libhello.so", "*")
stdin:1: attempt to call global 'loadlib' (a nil value)
stack traceback:
    stdin:1: in main chunk
    [C]: in ?

Lua表示在全局域中没有loadlib。google后发现两种解决方案：

第一种认为这种错误是因为没有把loadlib编译进lua中，需要改makefile.如此贴的楼主所述： http://lua-users.org/lists/lua-l/2009-02/msg00463.html

第二种是在csdn上的贴子，要改lua的源文件中的一个define，实际上这种方法也是可以在makefile中define一个变量的。

不过！！！

问题其实更简单，不需要改什么makefile文件：

http://lua-users.org/lists/lua-l/2009-02/msg00466.html

lua在5.0以后，loadlib已经不在全局域中了，loadlib在package名字空间中了。

这样就好了：

package.loadlib(“libhello.so”, “*”)

实际上，loadlib是一个底层的函数。不像require,loadlib不在path里进行查找，也不自动添加文件名后缀。这个函数在某些平台上不被支持，因为ANSI并没有要求支持动态链接库。

什么是0MQ或ØMQ，或ZeroMQ

Sat, 18 Jan 2014 10:39:00 +0000

ØMQ或者拼写成ZeroMQ,0MQ，是一个高性能异步消息队列库，旨在在分布式可扩展的并行程序中使用。它提供了一个消息队列，但不像面向消息的中间件，即使没有特定的消息经纪人(Message Broker)，0MQ也能正常工作。

这个库在TCP的基础上开发，但能获得比TCP更高的性能，更不用说它提供了各种安全机制和分布式易扩展的特性。

0MQ的API和传统的socket很像。OMQ中的socket描述了一个,多个终端之间的多对多的连接。0MQ还有一个消息模式的概念。基本的0MQ消息模式有：

Request-reply:

用来连接一组客户端和一组服务。这个模式是一个远程过程调用RPC，和多任务分发模式。

Publish-subscribe:

用来连接一组发行端和一组接收端。这是一个数据分发模式。

Push-Pull(Pipeline)

用扇入/扇出模式连接很多结点，通常要分好几个步骤。这是一个多任务并行分布和收集的模式。

Exclusive Pair:

用排它模式连组两个socket。这其实是一个为特殊需求准备的高级底层模式。

每一种模式定义了一个对应的网络拓扑。Request-reply模式定义了所谓的”服务总线”，publish-subscribe定义了数据分发树，push-pull定义了并行管道。这样模式都被精心设计，使他们可以在互联网上被无限扩展。

不想译了,。更多内容见wikipedia。kamuszhou@qq.com 腾讯视频广告

Git 的M,T,D,A,U标志是什么意思

Fri, 17 Jan 2014 08:56:20 +0000

在使用git checkout , git status，或git diff files时会出现奇怪的标志。如M,T,D,A,R,U等等。

如：

# git checkout master

M cpp-iniparser

文件cpp-iniparser前面有个M. git的这些奇怪标志是什么意思呢。

A: 增加的文件.

C: 文件的一个新拷贝.

D: 删除的一个文件.

M: 文件的内容或者mode被修改了.

R: 文件名被修改了。

T: 文件的类型被修改了。

U: 文件没有被合并(你需要完成合并才能进行提交)

X: 未知状态。(很可能是遇到git的bug了，你可以向git提交bug report)

在git diff-files的手册man git diff-files中可以查到这些标志的说明。

这些状态标志在git的源代码的diff.h文件中被定义。

使用Git的submodule功能管理第三方库

Thu, 16 Jan 2014 06:40:00 +0000

用Git的Submodule功能来管理代码中使用的其它库，还是满方便的。主要用到三个命令:

Git submodule add, git submodule init, git submodule update.

git submodule init to initialize your local configuration file and git submodule update to fetch all the data from that project and check out the appropriate commit listed in your superproject.

还有两个查看相关信息的命令git submodule summary,和 git submodule status.

Git的submodule功能带来的好处和坏处都很多，网上有大量的贴子反对使用git submodule。

我觉有限制地，在以下场景用git submodule管理第三方库的代码还是很不错。

1. 你使用的第三方库更新非常慢，甚至不更新，它的接口很稳定。比如：管理vim的插件们。

2. 第三方库以比较固定的周期更新。于是，过一段时间再把上游的代码拉到submodule上来。

3. 第三方库虽然更新很快，但我过一段时间才拉取上游代码也无所谓。

如果单开一个git clone管理第三方库，与自己的项目平行，当然也是可以的。但这样有个问题是，别人git clone了你的项目，还需要再git clone一次你的项目依赖的项目，并放在适当的相对路径上。而使用git submodule *时，你的项目和你依赖的库是层级关系，有条理得多。

还有一种方式是把第三方库的代码合并到自己的代码中。这样做的坏处是显而易见的，如果你要合并上游代码的FIX或功能加强，都非常的麻烦。大多数人是不会去做这个同步的，于是代码会被手动复制，越来越多的细微改动分散在各个不同的项目的相同/相近代码中。一片混乱….

使用Git Submodule时忽略Submodule的改动：

如果submodule中有生成新文件。在父工程(superproject)中用git status，就总会提醒你git submodule子模块有还没被跟踪的文件。

比如：一次make会生成很多.o，.dep文件。比如用git submodule管理vim插件会生成各种临时文件。你不想让git status提醒你，这多么烦人啊。

如下，git status总提醒我cpp-iniparser子模块有未跟踪的文件：

root@vicarious:/home/kamus/projs/horoscope# git status
# On branch dev
# Changes not staged for commit:
# (use "git add …" to update what will be committed)
# (use "git checkout — …" to discard changes in working directory)
# (commit or discard the untracked or modified content in submodules)
#
#   modified: configuration.cpp
#   modified: configuration.h
#   modified: cpp-iniparser (untracked content)

HTTP中的HEAD方法是什么

Wed, 08 Jan 2014 02:29:55 +0000

HTTP中的HEAD方法和GET方法是一样的，除了服务器在响应HEAD方法时不充许活加消息体(message body).服务器用来回复HEAD的响应信息中，在HTTP头部中的元信息需要跟回复GET时一样。这样，一个客户就可以通过HEAD来得到某资源的源信息，而不需要把整个资源都传输一次。

HEAD方法通常被用来测试超链接的可达，和资源是否已经更新。

HEAD方法的主要应用场景是检索资源的元信息meta infomation。用getResponseHeaders()函数可以得到HTTP的头部~

configure –prefix 和 make install DESTDIR= 还有make install prefix 什么区别

Mon, 06 Jan 2014 02:19:04 +0000

./configure –prefix=*

确定了程序会被包装到哪里，以及，程序将在什么位置搜寻运行需要用到的相关的文件。如果你在一台机器上编译，然后仍然在这台机器上运行，那使用configure –prefix就是你想要的了。

make install DESTDIR=*

把程序安装到一个临时用的目录，这个目录不是程序以后将要运行的目录。例如，这个功能被deb包的打包人员使用。打包人员使用此功能时，并不真正把程序安装到–prefix指定的目录下。因为他可能已经安装了不同的版本，他不想搞乱他的环境，或者他没有boot权限，没有办法把程序安装到/bin,/sbin之类目录。 –prefix=/usr，让程序运行时认为被安装在/usr，然后make install DESTDIR=debian/tmp则实际把程序安装到debian/tmp。

make install prefix=/foo/bar/baz

和 make install DESTDIR的区别在于，前者不会创建prefix后面指定的所有目录层级，而DESTDIR会。

例如：

./configure –prefix=usr/local && make && sudo make install prefix=/usr/local/stow/foo 会把程序安装在/usr/local/stow/bin目录下。

而: make install DESTDIR=/usr/local/stow/foo，则把程序安装在/usr/local/stow/foo/usr/local/bin下面。

抓包程序的一些分享

Thu, 26 Dec 2013 02:13:56 +0000

昨晚同白总和adden提到抓包的问题。因为写过相关的代码，遇到过抓包的各种各样的坑，此文分享一些相关的经验。

1. Linux cooked capture

在用tcpdump或wireshark看数据包时，有时会看到数据链路层的的包头称为Linux cooked capture。这不是一个真实的包头，当用tcpdump指定从所有网络介质 -i any 抓包时，所有抓到的包的数据链路层被换成了Linux cooked capture。在wireshark官方网站对Linux cooked capture的解释中: 这是一个在linux上被libpcap抓包库使用的“假协议”(pseudo-protocal)，当从“any”设备在抓包，或者本地的数据链路层包头无效时被使用。更多，见 http://wiki.wireshark.org/SLL

2. IP over IP tunnel

wikipedia的示例图显示IP tunnel上的包的结构是：

但实战中用libpcap库从我们的线上机的IP隧道抓包时，pcap_loop或pcap_dispatch或pcap_next函数返回的数据包只有Inner IP header + IP payload，没有Outer IP headr，也没链路层的头部。多么幸运啊！

3. 混乱的RAW_SOCKET，PF_PACKET协议族

这不是工业标准定义的神秘领域，非常之混乱，谨慎进入。如果要写这方面的socket，可供参考。个人经验，用linux原生的socket抓包时，socket()的三的参数如下组合时的神奇效果.

_recv_fd = socket(AF_PACKET, SOCK_DGRAM, htons(ETH_P_IP));

从此socket中读所有的IP包，返回的IP包没有链路层包头,因为第二个参数是SOCK_DGRAM，链路层包头返回时被去掉。第三个参数指定的是IP包。奇怪的是，如果出站的IP包的目的地址不是本机，则出站的IP包不会被抓到。

_recv_fd = socket(AF_PACKET , SOCK_RAW , htons(ETH_P_IP));

和上一个socket的区别是，这个会返回链路层包头。和上一个socket一样，同样只能装到部分出站的包。

_recv_fd = socket(AF_INET, SOCK_RAW, IPPROTO_TCP);

这行代码只可以读入站的包，抓不到出站的包。

_recv_fd = socket(AF_PACKET , SOCK_RAW , htons(ETH_P_ALL));

为什么dump生成core文件大小是0

Wed, 25 Dec 2013 05:17:38 +0000

今天程序崩溃了，但是生成的core文件大小是0.

用ulimit -c 查看生成core文件的大小限制是无限unlimited.

也不是磁盘大小和写入权限的问题。

但究竟是什么问题呢？

捣了半天终于搞明白，原来是文件系统造成的。

我是在vmware的虚拟机的debian linux上运行程序，文件系统用的是从host机windows 7挂载到/mnt/hgfs的windows的NTFS文件系统。

后来我把程序转移动linux自己的文件系统，崩溃的时候就生成正常的core dump文件了。

CDT调试中的追踪点和断点有什么区别。

Wed, 11 Dec 2013 02:31:13 +0000

追踪点（Tracepoint）被当成断点(breakpoint)的一种，但有两个不同点需要注意：

1. 当一个追踪点在一个调试会话中被创建时，它并不种入到二进制代码中，直到用户显式地开始追踪实验。这意味着，创建/修改/删除追踪点并不影响程序，直到追踪真正开始。

2. 简单的创建一个追踪点并不是非常有价值，因为它默认不会收集任何信息。重要的是，把操作(Actions)添加到Tracepoint，这样tracepoint被触发的时候，前面自定义的Action就大有用处了。

来自CDT官网的原文：

Create Tracepoints

让eclipse自动生成的注释的时间显示英文，不用中文.

Mon, 09 Dec 2013 08:21:55 +0000

这几天换成用eclipse在windows机器上编写代码，远程运行在linux上，并且在windows机器上远程调试。

新建一个C++类的时候，eclipse/CDT自动生成注释，注释的时间用了中文，并且用的注释风格也不是我想要的。

但我想全部用英文，这个如何解决了。在stackoverflow上找到了答案，并试验成功。

windows -> preferences -> c/c++ -> code style -> code template

在右边的注释模板中编辑File Comment，改成你想要的模式。比如我的：

/*****************
* ${file_name}
* Author: ${user}
* Created on: ${date}
******************/

再在eclipse的安装目录上找到eclipse.ini文件，加入：-Duser.language=en_US

重启eclipse。现在${date}变量生产的日期就是全英文了。

CPRP和CPT是什么意思，有什么区别

Fri, 06 Dec 2013 07:52:33 +0000

CPRP是Cost Per rating Point的缩写， CPT是cost per thousand的缩写。

举例来说，某一个电视节目的一个商业广告时间槽位(commercial time slot)的价格是$1000，这个电视节目的收视率是10%（program rating），那么CPRP就是$1000除以10，即$100。

而CPT则是广告到达某一个特定人群的花费。

如何从windows远程调试linux程序。

Wed, 04 Dec 2013 03:29:06 +0000

用gdb在远程linux机器上调试程序实在太不方便了。于是想到用eclipse的GUI调试。下面介绍如何从windows远程调试linux程序。

设置变量GIT_CURL_VERBOSE可以帮助调试git出错

Wed, 27 Nov 2013 04:43:22 +0000

今天操作git的时候又出错了:

error: Failed connect to github.com:8080; No route to host while accessing https://github.com/zausiu/gryphon/info/refs
fatal: HTTP request failed

之前用公司的http代理上git,

#git config -l

http.proxy=http://web-proxy.oa.com:8080

设置变量GIT_CURL_VERBOSE可以看到详细的出错情况：

#export GIT_CURL_VERBOSE=1

# git pull

Couldn’t find host github.com in the .netrc file; using defaults
About to connect() to proxy web-proxy.oa.com port 8080 (#0)
Trying 10.14.36.100…
0x23d67b0 is at send pipe head!
STATE: CONNECT => WAITCONNECT handle 0x23df5f0; (connection #0)
No route to host
Failed connect to github.com:8080; No route to host
Closing connection #0
Couldn’t find host github.com in the .netrc file; using defaults
About to connect() to proxy web-proxy.oa.com port 8080 (#0)
Trying 10.14.36.100…
0x23d67b0 is at send pipe head!
STATE: CONNECT => WAITCONNECT handle 0x23df5f0; (connection #0)
No route to host
Failed connect to github.com:8080; No route to host
Closing connection #0
error: Failed connect to github.com:8080; No route to host while accessing https://github.com/zausiu/gryphon/info/refs
fatal: HTTP request failed

packet captured和packet received by filter到底有什么区别

Fri, 22 Nov 2013 05:22:58 +0000

我用的是linux. 结论是 packet received by filter是tcpdump从内核中拿到的且匹配命令上行指定的过滤条件的包， packet captured是经由pcap_loop, 或 pcap_dispatch 或 pcap_next，把包交给回调处理过的包的数量。这两个数字的差值是tcpdump抓到的，还来不及处理的包。

下面是讨论的一些细节:

/////////////

tcpdump的最后输出. 592个包captured, 1184个包received by filter。。这个差值是不是表示有多少包tcpdump没来得及处理.

man tcpdump上写得好复杂，received by filter的数字取决于OS… 1. 包匹配不匹配命令行上指定的filter都算，如果匹配，有没有被tcpdump读出都算.. 2. 只有匹配命令行上指定的filter的包才算，有没有被tcpdump读出都算. 3. 只有匹配filter才算，只有被tcpdump读出才算.

我的理解是：如果是第3种，那captured的数字和received by filter的数字就是一样的。第2种的差值表示tcpdump来不及处理的包数量，理想状态上差值能为0. 第1种情况，基本上总是有差值。

我猜测我用的linux上应该是第2种情况.

wangbin579() 10:18:54
应该是匹配的才算received by filter，但奇怪的是，为啥你的系统，captured怎么少？
wangbin579() 10:19:30
[root@hz0-12-157 ~]# tcpdump -i any tcp and port 36524 or 3306 -w all.pcap
tcpdump: listening on any, link-type LINUX_SLL (Linux cooked), capture size 65535 bytes
10757 packets captured
11171 packets received by filter
334 packets dropped by kernel
wangbin579() 10:20:07
我们这边系统，基本可以认为packets received by filter=packets captured + packets dropped by kernel

siu¹ººººººº() 10:23:38
/homemus/tmp # time time tcpdump -i tunl0:1 -w tmp
tcpdump: listening on tunl0:1, link-type RAW (Raw IP), capture size 96 bytes
19508 packets captured
39021 packets received by filter
0 packets dropped by kernel
0.01user 0.02system 0:17.04elapsed 0%CPU (0avgtext+0avgdata 0maxresident)k
0inputs+0outputs (0major+506minor)pagefaults 0swaps

real    0m17.139s
user    0m0.012s
sys     0m0.028s
wangbin579() 10:26:03
如果是差是丢包，那么通过查看抓包文件，应该能看出很多不完整的session
siu¹ººººººº() 10:28:46
我觉得差值是来不及写入磁盘的包.
siu¹ººººººº() 10:29:04
再研究看看了。。谢谢啦/..
wangbin579() 10:30:03
packets captured是pcap_loop所设置的回调函数所调用的，一旦调用回调函数，就用统计
wangbin579() 10:30:37
有可能内核态部分和用户态部分，速度上不匹配，有延迟导致的？
siu¹ººººººº() 10:32:33
我现在理解, received by filter是pcap库从内核中拿到的又匹配命令行上filter的包的数量， packets captured是经由pcap_loop, pcap_dispatch之类通过callback交付出去的包数量. 差值就是还没来得及处理的.
wangbin579() 10:32:48
17s，每秒也就2000多个，不算多，用户态程序应该来得及处理

wangbin579() 10:33:58
我这边系统很破，处理速度也比这个快，也没有来不及处理
wangbin579() 10:34:45
看看我的：
wangbin579() 10:34:47
[root@hz0-12-157 ~]# time tcpdump -i any tcp and port 36524 or 3306 -w 3306.pcap
tcpdump: listening on any, link-type LINUX_SLL (Linux cooked), capture size 65535 bytes
294663 packets captured
295432 packets received by filter
693 packets dropped by kernel

real    0m17.676s
user    0m0.897s
sys     0m3.502s
wangbin579() 10:35:52
量比你大7倍多，也没有出现来不及处理啊，当然我的是物理机，3G内存，
siu¹ººººººº() 10:36:59
呃那你觉得这个差值不是来不及处理的包么？。我觉得应该还是来不及处理的。我在想，可能是写到的磁盘文件系统是NFS之类的 ….我继续排查一下。
wangbin579() 10:37:43
有可能，我的是写入本地磁盘。
wangbin579() 10:37:58
你这种情况，我还是第一次碰到
siu¹ººººººº() 10:39:05
我先去运维那边了解下情况…多谢啦
wangbin579() 10:39:18
算涨见识了，还以为一般dropped by kernel为0就代表不丢包呢，居然还有你这种情况。
你可以看看抓包文件，session是不是很多不完整，如果不完整，你的推测是对的
siu¹ººººººº() 10:39:58
嗯。呵呵~~ 做IT，每天都会碰到挑战宇宙规律的现象。
siu¹ººººººº() 10:40:07

мe(～ o мe(632813052) 10:41:09
呵呵
wangbin579() 10:41:24
其实，网络方面的问题，最复杂了。
我现在已经陷入到网络的汪洋大海之中了，各种各样的问题都会有，而且没有尽头。
早知道如此，3年前我就不搞这一块了
siu¹ººººººº() 10:42:30
同感。写一点点代码，都非常难以调试。各种认为理所当然的假设，通通是bug的温床

@wangbin579 麻烦你在tcpdump前加个time，。。把输出贴出来。我好像看出问题来了。

[root@hz0-12-157 ~]# time tcpdump -i any tcp and port 36524 or 3306 -w 3306.pcap
tcpdump: listening on any, link-type LINUX_SLL (Linux cooked), capture size 65535 bytes
294663 packets captured
295432 packets received by filter
693 packets dropped by kernel

real    0m17.676s
user    0m0.897s
sys     0m3.502s
wangbin579() 10:56:03
不是加了time了吗？
wangbin579() 10:57:15
[root@hz0-12-157 ~]# time time tcpdump -i any tcp and port 36524 or 3306 -w 3306.pcap
tcpdump: listening on any, link-type LINUX_SLL (Linux cooked), capture size 65535 bytes
^C202061 packets captured
202523 packets received by filter
369 packets dropped by kernel
0.66user 2.50system 0:11.99elapsed 26%CPU (0avgtext+0avgdata 24208maxresident)k
0inputs+105656outputs (0major+660minor)pagefaults 0swaps

real    0m11.999s
user    0m0.661s
sys     0m2.506s
wangbin579() 10:57:26
加两个，结果如上
siu¹ººººººº() 10:59:29
问题找到的。我这边运行的tcpdump，根本就没有抢到cpu时间来处理.
wangbin579() 11:00:05

siu¹ººººººº() 11:00:06

Real 0m3.914s

User 0m0.008s

Sys 0m0.000s

跑了4秒钟，用户空间才抢到0.008秒，内核态几乎是0 ….
siu¹ººººººº() 11:00:25
那个差值确实是没有来得及处理的包的数量。
wangbin579() 11:00:41
奥，那你系统这么繁忙啊

siu¹ººººººº() 11:02:22
所以，解决了一个问题又会有新的颠覆宇宙规律的问题…系统负载很高，但cpu使用率很低。。

昨天解决了tcpcopy的一个小却很重要的bug.

Wed, 20 Nov 2013 02:48:59 +0000

tcpcopy的基础函数有个bug，流量比较大的时候，内核buffer满了。send系统调用发不完用户缓冲中的数据才会出现。然后加入了tcpcopy的QQ群，和作者稍稍讨论了一点时间。问了关于写论文和tc_session.c过于复杂的问题。

(wangb) 10:00:55
https://github.com//tcpcopy/pull/162
(wangb) 10:01:04
The bug arises when send system call returns with part of data transfered
and part of data still need to be sent again.
(wangb) 10:01:13
常见于压力比较大的场合
(wangb) 10:02:14
当然如果系统参数设置好的话，这样的情况不常见。这也是为啥我这边无法重现的原因所在
(wangb) 10:02:46
当然昨天在开发gryphon，貌似遇到过一次
(wangb) 10:03:06
gryphon给的压力，有时候真不是一般快和大
siu1ooooooo(16236914) 10:03:14
我在tcpcopy上作二次开发。碰到了个bug，最后追踪到了 tc_socket_send函数。
siu1ooooooo(16236914) 10:03:52
流量比较大的时候，内核buffer满了。send系统调用发不完用户缓冲中的数据才会出现。
siu1ooooooo(16236914) 10:05:21
希望能贡献更多代码的。。但是tc_session.c这个模拟tcp状态机的代码太难看懂了。
(wangb) 10:05:49
有些bug，程序员自身很难发现，往往需要依赖于用户的反馈，当然有上面的bug提出，就更好了
tc_session.c这个模拟tcp状态机，其实不仅模拟tcp状态机，而为复杂的是模拟上层应用交互
光模拟tcp状态机，是远远不够的
siu1ooooooo(16236914) 10:07:27
有个想法，把TCP的11个标准状态加入到tc_session中。可不可以做的。.
(wangb) 10:09:13
数据是死的，但测试服务器是活的。应该可以吧，但加入可能会更复杂。tc_session.c这个会进一步改进的，代码需简化和功能需独立，使其易懂
siu1ooooooo(16236914) 10:09:31
🙂
(wangb) 10:10:33
2010～2012.5月，初步探索阶段；2012.5～2014.5，为进一步探索阶段 2014.5～以后，进一步优化
因为tcpcopy刚开始，开发人员是无法知道复杂的互联网的各种应用的特性的，只有积累到一定程度，才能进一步优化。与其说是开发，不如说是探索
siu1ooooooo(16236914) 10:12:10
期待工程paper
siu1ooooooo(16236914) 10:12:43
tcpcopy稳定到了一个版本。先别加功能了。写paper吧
siu1ooooooo(16236914) 10:13:01
投中EI应该问题不大。
siu1ooooooo(16236914) 10:13:55
中了paper，贡献者会迅速增多。
wangb() 10:15:43
其实写过sigcomm论文，但被拒，说应该投USENIX ATC
wangb() 10:16:18
I don’t think that the research contribution of the paper is a good match for Sigcomm. Perhaps it would be a better match for
a more practice-oriented conference like USENIX ATC.
siu1ooooooo(16236914) 10:16:50
后来呢
wangb() 10:17:05
确实，tcpcopy是基于实践的，从实践中摸索爬行的。后来我就先不写论文了
siu1ooooooo(16236914) 10:17:22
嗯。这是个工程实践性很强的探索啊
wangb() 10:17:27
要写论文，必须要有条件
siu1ooooooo(16236914) 10:17:45
喔。
wangb() 10:18:06
从交换机或者其它设备。镜像过来，这样测试系统和在线系统就没有关联，这样的论文是能够中USENIX ATC
的
wangb() 10:19:13
tcpcopy最高端的应用，就是在交换机，利用分光镜或者其它镜像设备，利用高性能硬件，把用户的请求数据包复制给测试系统，可惜我没有这样的条件
wangb() 10:19:38
要是有这样的条件，我肯定要写论文了
siu1ooooooo(16236914) 10:19:55
呃。。没怎么看懂
siu1ooooooo(16236914) 10:21:49
是说复制的流量要非常非常大才能中论文么
siu1ooooooo(16236914) 10:21:59
而非常大的流量需求硬件支持
wangb() 10:22:02
twitter梦想的测试环境，其实完全可以用我们的tcpcopy来实现。交换机上面不是有来来往往的数据包吗？在那上面把请求数据包镜像到测试系统，测试系统搭一个跟在线类似的完整系统，这样测试系统跟在线系统承受类似的压力
wangb() 10:22:17
高端大气，才能中论文
wangb() 10:22:48
屌丝环境，写论文，还不被批啊
siu1ooooooo(16236914) 10:23:14
呃。是。。。明白了。。想起以前学校的事情，懂了。
wangb() 10:24:38
总之，tcpcopy值得你去研究，期望有更多接班人把思想传承下去，代码可以推掉重来
wangb() 10:25:10
只要tcp协议还存在，这个思想，应该是最先进的，无法再先进了
siu1ooooooo(16236914) 10:26:11
需要好多的开发时间啊。..嗯。先上班了啊。多谢wangbin….
wangb() 10:27:16
慢慢来，这方面反正国外没有人做

为什么我的名字没有出现在github的contributor列表中.

Wed, 20 Nov 2013 02:02:15 +0000

为什么我没有出现在github.com的contributor列表中.

我提交了commit，但为什么我没有出现在贡献者列表中呢。有三个原因：

1. 检查你的commit中的邮箱信息，这个邮箱必须和你的github.com账号关联。怎么关联邮箱账号呢。先选择Account Setting, 在左边先Emails，于是就看到可以verify邮箱地址的页面了。关联邮箱地址后还有过一段时间，贡献者列表才会更新。

2. 如果工程的贡献者名单列表超过了100个。就不会显示100个以后的贡献者了。官方HELP中说这是为了性能的考量。我觉得是码农偷懒，必竟这个需求太小了。绝大多数工程不会超过100个贡献者，于是码农不想解决这个小问题。

3. 你的commit必须被提交到工程的默认分支上。如果提交到其它的分支上，你的名字就不会被显示。

为什么我没有出现在github.com的contributor列表中.

我提交了commit，但为什么我没有出现在贡献者列表中呢。有三个原因：

3. 你的commit必须被提交到工程的默认分支上。如果提交到其它的分支上，你的名字就不会被显示。

如何删掉github上的master分枝.

Fri, 01 Nov 2013 04:53:26 +0000

假设，代码已经被clone到了本地。第一步要做的就是创建一个新的分支，比如placeholder，然后用-D从本地删除master分支。

git branch placeholder
git checkout placeholder
git branch -D master

如果现在删除github上的master，会报错：

tcpcopy在视频广告组的二次开发

Wed, 16 Oct 2013 09:01:05 +0000

流量筛选中的 “只导入某频道的流量”功能已经实现了。

技术层面上，实际上是通过指定正则式的方法匹配HTTP请求中的GET方法中的URL来达到过滤的目的。

所以，也可以用ty，ad_type, pf, coverid, oadid, v，plugin等出现在GET方法中的参数编写正则式来过滤流量。

流量筛选中的“地域纬度筛选”暂时没有实现。

因为地域纬度的信息不是以参数形式出现在GET方法的URL中，需要通过IP地址或者cookie的中QQ号信息来判断。

还没最终决定是否实现这个功能。

tcpcopy官方版本主要的应用场景是复制实时流量。所以部署的时候至少两台机器，一台线上机，另一台测试用机。为了方便压力测试，还引入了至少三台机器的高级模式。

部署起来比较麻烦。

如果“视频CPM广告的模拟投放，以及订单效果预估“只是从磁盘中读入以往的流量，针对这种场景，可以探索tcpcopy的单机离线模式，做到方便部署和使用。

部分同学有一个误解.

“将线上的实际访问流量，复制一份保存到本地服务器，用于后续使用”

目前，tcpcopy的官方的版本没有把流量保存下来的功能，保存流量这个目前是用tcpdump的-w选项来做的。

另外，技术上，tcpdump只能在IP层和TCP层指定过滤条件，不能用业务的逻辑过滤流量。第1点提到的流量筛选工作在tcpcopy读入实时流量时，或者从tcpdump存下的文件中读入流量时，在应用层指定过滤条件。

Linux抓包技术简介

Tue, 10 Sep 2013 05:05:03 +0000

Linux抓包技术简介

Author: zausiu@gmail.com

1. 简介

大多数应用常景下，我们在IP层上用AF_INET或AF_INET6作为socket的第一个参数，SOCK_STREAM或SOCK_DGRAM作为socket的第二个参数创建最为常见的IPv4或IPv6的TCP或UDP套接字。这样的套接字满足了绝大多数网络应用常景。

本文简单介绍三种Linux平台下抓包，截获包的技术。它们提供一些更酷的功能。每种技术的水都很深，作者个人水平有限，按照自己的理解做一般的介绍。仅仅旨在起到科谱的作用。

2. RAW SOCKET

参数SOCK_RAW可以作为socket函数的第二个参数传入，这样创建的套接字称为原始套接字。设置Socket的第一个参数可以让指定原始套接字开在数据链路层上或者网络层。

下面的语句创建在数据链路层上的原始socket。

Socket(AF_PACKET, SOCK_RAW, htons(ETH_P_ALL));

在负载不大的情况下，读这个socket可以拿到本机收到的所有数据包。写入这个socket需要程序员负责填充各种包头的数据。

Socket(AF_INET, SOCK_RAW, xxxxx协议号)；

在IP层上创建IPv4的RAW socket，可以拿到各种经由IPv4的数据包，比如ICMP包，IGMP包等。Steven的第三版第28.4节，第二段：“系统收到的UDP包和TCP包不会传给原始套接字”。但读tcpcopy的源代码时，确实用了原始套接字在网络层读UDP和TCP包。难道书上写的过时了。见代码，来自tcpcopy：

#if (TCPCOPY_UDP)

fd = socket(AF_INET, SOCK_RAW, IPPROTO_UDP);

#else

fd = socket(AF_INET, SOCK_RAW, IPPROTO_TCP);

#endif

另外，在IP层上创建的原始套接字有一个选项：IP_HDRINCL，它被开启时，则内核帮助填充IP包头。Linux默认没有开启这个选项。

3. NF_Queue

NF_Queue是用户空间的一个库，需要内核模块NETFILTER_NETLINK_QUEUE的支持。官方网址：http://www.netfilter.org。通过这个库可以在数据包被发往用户空间处理前截获数据包，或者在数据包被发往网卡前截获数据库。截获后，可以修改数据包的内容，并决定是否丢充这个数据库。

NF_Queue可以用来编写防火墙等安全软件。

Tcpcopy使用NF_Queue丢弃测试中的程序回复给真实客户程序的数据包，使测试中程序回复的报文不影响真实客户程序。

另一个提供类似功能的库是IP_Queue，它已经被废弃。NF_Queue可以完全取代IP_Queue。我们用的tlinux，内核中built-in了NF_Queue模块。

4. libpcap

大名鼎鼎的Libpcap是一个古老的可以工作在所有Unix-like平台上的抓包库，比linux年纪更大。Tcpdump的广泛使用让libpcap成为事实上的行业标准。它可以很方便的编写抓取数据链路层上的数据包，并可以设置过滤条件在内核级别只复制关心的数据包，而数据链路层上的原始套接字会尽最大努力复制所有的包，所以libpcap的工作效率高。而且，pcap使用方便。下面是一个很简单的使用pcap抓到发往80端口的tcp包并打印源IP，目的IP，和目的端口号的程序。非常短，很容易看，起到介绍libpcap的作用。

int main(int argc, char *argv[])

{

pcap_t *handle; // pcap用的句柄，和其它各种句柄一样。

char *dev; // 网络接口名，如eth0, eth1, tunl0 之类

char errbuf[PCAP_ERRBUF_SIZE]; // 存描述出错原因的缓冲

struct bpf_program fp; // pcap用来过滤数据包用

char filter_exp[] = "tcp and dst port 80"; // 过滤字符串，和tcpdump的写法一样

struct pcap_pkthdr header; // pcap自己用的包头

const u_char *packet; // pcap包头后的数据，即抓到的数据

int len_of_iphdr; // ip头的长度

struct in_addr src_ip; // 源IP地址

struct in_addr dst_ip; // 目的IP

const u_char *ip_hdr_addr; // IP头的首地址

const u_char *tcp_hdr_addr; // tcp头的首地址

struct tcphdr *tcp_hdr; // tcp头结构体

u_short dst_port; // 目的端口

// 如果命令行指定网卡名

if (argv[1])

dev = argv[1]; //就用指定的网卡

else

dev = "eth0"; //否则用eth0

}

// 用pcap打开这个网卡

handle = pcap_open_live(dev, BUFSIZ, 0, 1000, errbuf);

if (handle == NULL) { // 打开网卡出错

fprintf(stderr, "Couldn't open device %s: %s\n", dev, errbuf);

return(2);

}

// 编译过滤文件

if (pcap_compile(handle, &fp, filter_exp, 0, net) == -1) {

fprintf(stderr, "Couldn't parse filter %s: %s\n", filter_exp, pcap_geterr(handle));

return(2);

}

// 设置过滤条件

if (pcap_setfilter(handle, &fp) == -1) {

fprintf(stderr, "Couldn't install filter %s: %s\n", filter_exp, pcap_geterr(handle));

return(2);

}

// 抓包

packet = pcap_next(handle, &header);

// 至此packet指向抓到的一个目标端口号是80的数据链路层的包

// 它的包结构是 14字节以太网包头 + 可变IPv4包头 + TCP包头

ip_hdr_addr = (u_char*)(packet + sizeof(struct ethernet_hdr));

src_ip.s_addr = ((struct iphdr*)ip_hdr_addr)->saddr;

dst_ip.s_addr = ((struct iphdr*)ip_hdr_addr)->daddr;

len_of_iphdr = ((struct iphdr*)ip_hdr_addr)->ihl * 4;

tcp_hdr_addr = ip_hdr_addr + len_of_iphdr;

tcp_hdr = (struct tcphdr*)tcp_hdr_addr;

dst_port = tcp_hdr->dest;

// 经过上面的各种指针偏移，下面打印源IP和目标IP和目标端口.

printf("src addr %s\n", inet_ntoa(src_ip));

printf("dst addr %s\n", inet_ntoa(dst_ip));

printf("dst_port %d\n", ntohs(dst_port));

/* And close the session */

pcap_close(handle);

return(0);

}

5. 总结

本文只是一个非常简单的介绍。如需要进阶学习，Stevens的网络编译有更详细地关于Raw Socket的内容，研究NF_Queue技术则需要读源代码和收集散在社区各个角落的资料了，而讲libpcap有两篇很好的文章：

"Programming with Libpcap – Sniffing the network from our own application "用Libpcap编程，在我们的程序中嗅探网络。非常漂亮的pdf文档。

http://recursos.aldabaknocking.com/libpcapHakin9LuisMartinGarcia.pdf

The Sniffer’s Guide to Raw Traffic 嗅探器教程。斯坦福大学的Geek于大概2001年写的。

http://yuba.stanford.edu/~casado/pcap/section1.html

Linux是从什么时候开始支持线程的.

Mon, 09 Sep 2013 04:57:26 +0000

几天前和同事吃饭，谈论到一个问题：linux从什么时候开始支持线程。他说linux中的线程出现的很晚，直到2.2.x才有。

我觉得不对啊，怎么会那么晚。然后它用手机搜索了一下，linux对POSIX线程库的支持确实很晚，直到2.6.x才有。

但我觉得POSIX线程库只不过是用户空间用来创建线程的接口，并不能证明那么晚linux才支持线程。

后来用PC的时候搜索了一下，在The Linux Document Project的官方网站找到了答案：

http://www.tldp.org/FAQ/Threads-FAQ/Support.html

Does Linux support threads?

Yes. As of 1.3.56, Linux has supported kernel-space multithreading. There also have been user-space thread libraries around as early as 1.0.9. There is on-going effort to refine and make the kernel more reentrant. With the introduction of 2.1.x, the memory space is being revised so that the kernel can access the user memory more quickly.

用线上机测试tcpcopy基本通过。支持旧模式，Advanced模式失败

Mon, 09 Sep 2013 01:54:06 +0000

测试结果介绍：

tcpcopy在编译期配置成使用NFQueue模式，用Raw Socket
color:blue">抓包。线上机的流量被成功复制并导向测试机。经改动的tcpd初期工作正常。

改动版的tcpd(实际上是一个echo服务器)。测试机上的tcpd把收到的报文被打印到日志文件。但日志文件到6M+大小的时候，就停止打印。目前还没有查到原因，可能是改动后的tcpd的Bug。此时，tcpdump仍然抓到大量从线上机复制来的真实流量到达测试机。tcpcopy应该是工作正常的。

tcpcopy被编译成使用libpcap抓包时不能
color:blue">在线上机上正常工作。tcpdump没有抓到预期从线上机复制到测试机的报文。原因是：线上机10.130.68.100上的真实流量从网络接口tunl0:0进入，从网络接口eth1发出。分析tcpd的日志发现，tcpd使用libpcap只拿到tunl0的IP，没有发现tunl0:0的IP。需要了解IP隧道，和libpcap库的相关知识，有可能解决这个问题。

编译成使用Raw Socket抓包，和Advanced模式时，tcpcopy启动失败，错误日志显示Advanced
color:blue">模式只能使用libpcap库抓包。因此，只有在解决libpcap正确识别tunl0:0网络接口后，才能在线上机上运行tcpcopy。

预备知识：

Tcpcopy可以编译成用libpcap抓包或者使用Raw Socket抓包。Libpcap库是tcpdump使用的抓包库，Raw Socket是操作系统内建的功能。

官方文档建议用libpcap抓包，以获得更高性能和较低丢包率。

Tcpcopy在编译期指定工作模式。tcpcopy目前有两种工作模式，一种使用IPQueue技术或者NFQueue技术。NFQueue技术是用来替代IPQueue技术的。我们目前使用的tlinux，内建了NFQueue内核模块，没有开启IPQueue模块。因为NFQueue是内建的即CONF_XXXXXX = y，而不是编译成模块，即CONF_XXXXX = m, 所以我们在环境中不需要使用modprobe 加载IPQueue或者NFQueue模块。忽略官方文档中提到的modprobe ip_queue。

测试步骤：

使用NFQueue模式：

线上机：10.130.68.100

编译tcpcopy时指定使用NFQueue。不要指定 –enable-pcap，则默认使用raw socket抓包。用pcap抓包时识别不到网络接口tunl0:0，而tunl0:0是真实流量的入口。

# ./configure –enable-nfqueue

#./make

生成的tcpcopy在 src/tcpcopy 目录下。

运行tcpcopy命令，把流量复制到测试机：

# ./tcpcopy -x 80-10.213.243.156

测试机：10.213.243.156

编译tcpcopy时同样指定–enable-nfqueue，不要指定–enable-pcap。然后运行intercept

# ./intercept

使用Advanced模式：

因为暂时未能解决用libpcap识别到网络设备tunel0:0的问题，实际上Advanced模式暂时不能工作。根据以前的使用经验，用Advanced模式时需要注意两点：

1. 在./configure时指定 –enable-advaned 和 –enable-pcap。

2. Advanced模式需要两台测试机，需要设成一条路由把复制后的真实流量导向测试机。需要更改默认路由：删掉当前的默认路由，新的默认路由从正确的网卡指向测试机2的IP。

# route del default

# route add default gw 10.213.243.156 dev eth1

Tcpcopy初体验.

Mon, 26 Aug 2013 03:28:13 +0000

Tcpcopy 初体验

Tcpcopy是一个模拟真实流量的测试工具。它的工作基本思想是，从已经上线的服务器复制一份真实流量到测试服务器。Tcpcopy的代码开源，代码仓库放在https://github.com/wangbin579/tcpcopy。

经过初步学习，已成功在公司的测试机器上部署tcpcopy，并用简单的DEMO程序测试达到预期目的。

**1.**安装

因为作者写的安装介绍只提到最基本的信息，而测试环境各不一样，在我用的测试机的实际安装过程中碰到一些问题。这时问题在这里列出，以供后来者参考，以节省时间。测试机：10.12.194.199 ； 10.12.194.212 ； 10.12.194.214 。

1.1 需要额外安装的库：

需要在网站 www.netfilter.org 下载 libmnl， libnfnetlink， libnetfilter_queue 三个工程并安装。安装顺序为 libmnl， libnfnetlink, libnetfilter_queue，因为第三个依赖第二个，第二个依赖第一个。安装方法是GNU工具的传统三板斧方式： ./configure ; make; make install。这三个工程生成三个.so库放置到/usr/local/lib，而我们用的操作系统环境并没有把该目录列在默认查找库文件的目录列表中，因此要编辑 /etc/ld.so.conf 文件，把目录/usr/local/lib 加入，再运行 ldconfig 更新ld链接程序使用的cache。

1.2 IP_Queue****和NFQueue内核模块：

这两个内核模块给在用户空间编写处理内核空间中传递网络数据包提供接口。它们的区别是IP_Queue是旧的实现，仅支持IPv4，NFQueue是新的实现。Tcpcopy工程依赖这两个模块之一。

Tcpcopy官方文档中多次提到tcpcopy在内核版本小于3.5时默认使用IP_Queue，并在使用例子中有一步操作：

# modprobe ip_queue

这个操作是确保加载ip_queue模块到内核。

我们的测试环境的内核版本号是2.6.32，按照官方文档介绍，内核版本小于3.5，于是使用#modprobe ip_queue命令，结果报错显示我们使用的内核没有启用动态模块加载。

于是再用 # zcat /proc/config.gz 检查当前内核的配置，发现CONFIG_IP_NF_QUEUE is not set, 说明IP_Queue模块没有被buit-in，再查找NFQueue的配置项发现 CONFIG_NETFILTER_NETLINK_QUEUE=y。

所以，在我们的环境中，应该忽略官方文档中# modprobe ip_queue，我们的内核已经内建了比IPQueue更新的NFQueue****。

1.3 编译安装tcpcopy**：**

官方文档中把已经正常运行业务的服务器称为在线服务器(online server)，把运行待测试用的服务器称为目标服务器(target server)。

在在线服务器端运行配置命令时务必指定 –enable-nfqueue，这是因为我们用的内核中只有NFQueue，如果不指定这个选项，编译出的tcpcopy不会运行成功，会在日志文件中报错：please make sure ip queue is running.

# ./configure –enable-nfqueue –enable-pcap

virtualBox开机挂载windows分区，并把光盘镜源设为源

Wed, 21 Aug 2013 08:33:59 +0000

virtualBox开机挂载windows分区，并把光盘镜源设为源。

设置fstab文件。把windows的d,e,f盘分别开机挂载到了/misc/d /misc/e /misc/f 。/misc是自建的目录，是miscellany的缩写。

# cat /etc/fstab

# /etc/fstab: static file system information.

# Use ‘blkid’ to print the universally unique identifier for a
# device; this may be used with UUID= as a more robust way to name devices
# that works even if disks are added and removed. See fstab(5).

#
# / was on /dev/sda1 during installation
UUID=590c2b64-87b7-4f92-b32f-7133139be772 / ext4 errors=remount-ro 0 1
# swap was on /dev/sda5 during installation
UUID=1e4e1188-d057-4210-99e7-6f2d1529db80 none swap sw 0 0
/dev/sr0 /media/cdrom0 udf,iso9660 user,noauto 0 0
D_DRIVE /misc/d vboxsf rw,auto 0 0 0
E_DRIVE /misc/e vboxsf rw,auto 0 0 0
F_DRIVE /misc/f vboxsf rw,auto 0 0 0
/misc/d/debian_ios/debian-7.1.0-amd64-DVD-1.iso /misc/a_iso udf,iso9660 user,loop,auto 0 0
/misc/d/debian_ios/debian-7.1.0-amd64-DVD-2.iso /misc/b_iso udf,iso9660 user,loop,auto 0 0
/misc/d/debian_ios/debian-7.1.0-amd64-DVD-3.iso /misc/c_iso udf,iso9660 user,loop,auto 0 0

我的毕业论文.Linux桌面环境下内存去重技术的研究与实现

Tue, 20 Aug 2013 07:00:10 +0000

把我的毕业论文放上来，直接从word复制，所以图片会丢失。

在这里可以下载原稿 www.ykyi.net/upload/Research_and_Implementation_of_Memory_Deduplication_in_the_Linux_Desktop_Environment.pdf

中山大学硕士学位论文

Linux桌面环境下内存去重技术的. based on KSM

研究与实现

Research and Implementation of Memory Deduplication in

The Linux Desktop Environment

<td style="width:160px;">
  <p>
    周霄
  </p>
</td>

<td style="width:160px;">
  <p>
    王常吉副教授
  </p>
</td>

学位申请人：

导师姓名及职称：

论文原创性声明

本人郑重声明：所呈交的学位论文，是本人在导师的指导下，独立进行研究工作所取得的成果。除文中已经注明引用的内容外，本论文不包含任何其他个人或集体已经发表或撰写过的作品成果。对本文的研究做出重要贡献的个人和集体，均已在文中以明确方式标明。本人完全意识到本声明的法律结果由本人承担。

学位论文作者签名：

日期：年月日

学位论文使用授权声明

本人完全了解中山大学有关保留、使用学位论文的规定，即：学校有权保留学位论文并向国家主管部门或其指定机构送交论文的电子版和纸质版；有权将学位论文用于非赢利目的的少量复制并允许论文进入学校图书馆、院系资料室被查阅；有权将学位论文的内容编入有关数据库进行检索；可以采用复印、缩印或其他方法保存学位论文；可以为存在馆际合作关系的兄弟高校用户提供文献传递服务和交换服务。

保密论文保密期满后，适用本声明。

学位论文作者签名：导师签名：

日期：年月日日期：年月日

论文题目： Linux桌面环境下内存去重技术的研究与实现

专业：软件工程

硕士生：周霄

指导教师：王常吉

摘要

内存管理是操作系统中至关重要的部分。优秀的操作系统高效地管理有限的内存资源。Linux内核的内核同页合并（KSM）模块是在虚拟化兴起后为节省虚拟机使用的内存而发展的一种节约内存的技术。KSM通过合并相同内容页面的方式显著地降低了多个基于内核虚拟机（KVM）技术的虚拟机同时运行时系统使用的内存。实际上，KSM也能合并一般应用程序中的相同内容页面。但一般应用程序为了使用KSM技术合并内存，需要在源代码级别显式地调用相应的系统调用来告知KSM需要扫描的内存区域。对于一般用户来说，需要修改应用程序的源代码显然是一个太高的门槛。

本论文在认真研究了KSM模块的实现的基础上，增强了KSM的功能。新设计实现的KSM+使得用户可以不必修改应用程序的源代码就能利用KSM+合并相同内容的内存页面。另外原来的KSM算法依赖程序指定的内存区域有大量的重复内存页面，而实际上，一般应用程序并没有大量的重复内存。在重复内存非常少的情况下，对这些程序应用KSM技术非但不能降低内存使用，而且因为运行KSM本身所需内存而增加了内存开销。本论文针对这一点在KSM的算法上做了改进，减少了运行KSM+算法本身所消耗的内存。然后论文用Linux桌面下的常用应用程序验证了KSM+的实际效果，并构造了一个实验比较了KSM和KSM+。最后，为了了解应用程序的重复内存页面的特点，还编写了专门统计重复页面的内核模块，发现应用程序的重复页面的一些规律，为持续改进KSM+提供了依据。

关键词：KSM，重复内存合并，内存管理

Title: Research and Implementation of Memory Deduplication in The Linux Desktop Environment

Major: Software Engineering

Name: Zhou Xiao

Supervisor: Wang Changji

Abstract

Memory management is one of the most important parts of the operating system. KSM (Kernel Samepage Merging) in Linux kernel is a kind of memory saving technology developed after the emerging of virtual machine. KSM can dramatically decrease the memory usage of the hypervisor running several virtual machines. Actually, KSM can also be applied to normal applications. But in order to use the KSM, application must explicitly evoke a system call in source code level to tell KSM the memory area where the KSM will scan. To normal users, modifying the source code is impossible at most of the time.

Base on the full grasp of the implementation of KSM, a new implementation named KSM+ is created, which allows users to merge same-content pages on the specified applications without modifying corresponding source code. Moreover, the original KSM algorithm relies heavily on the specified area is rich in same-content pages, while normal applications have much less same-content pages compared to virtual machines. So, when KSM is applied to those applications, it is possible that memory usage will rise rather than decrease. To combat with this situation, KSM+ employs a new algorithm to decrease the memory usage for running itself. Several experiments prove that the KSM+ can be easily applied to specified applications and memory usage can be reduced. And a case is designed to compare the effect between KSM and KSM+, which shows KSM+ behaves better in deduplication when the same-content pages’ density is very low. At last, in order to inspect the characteristics of same-content pages from normal desktop applications, an ad-hoc kernel module is developed to do the statistics which supplies significant data for the further development of KSM+.

Key Words： KSM, Deduplication, Memory Management

epoll学习报告

Wed, 07 Aug 2013 12:01:31 +0000

epoll学习报告

kamuszhou 周霄 Jul/26/2013

这几天通读了内核中对epoll I/O模型的实现代码，结合网络上很多介绍epoll的文章，对epoll的实现原理已经很熟悉，下面谈谈我的几点体会。下文引用的内核代码来自3.9.6版本的内核，见URL：http://lxr.oss.org.cn/source/fs/eventpoll.c。

一. epoll的边沿触发(ET)的效率高于电平(LT)触发的效率

首先简单介绍一个背景：epoll实现中，把已经有事件发生的文件用一个双链表链接一起，这个双链表是在struct eventpoll结构中的rdllist域。用户空间调用epoll_wait()，陷入内核后就会立即检查这个双链表，如果链表中非空，就通过文件的poll()函数询问文件有无事件发生。如果有事件发生且是用户关心的，就会向用户空间报告，否则就睡眠。

epoll的实现代码中实际上只有两行代码与触发方式有关，如下图所示。

上图所示的代码运行的上下文情况是：用户加入到epoll中的某个文件，只要支持poll()，(可以是socket，FIFO，裸设备，whatever)有关心的事件到达(或可读，或可写，或报错)，内核空间已经把发生的事件复制到了用户空间，但还没有从内核态返回用户空间。在返回用户空间之前代码检查用被epoll监视的这个文件是否是ET触发，如果不是(那就是LT),就把监视的文件重新放回就绪队列，下次epoll_wait()调用的时候会立即重新检查这个文件有否有事件到达。如果这文件的确有事件发生，则epoll_wait()报告给调用者。如果没有，而且其它被监视的文件也没有事件发生，则调用epoll_wait()的task就让出处理器，开始睡觉(TASK_INTERRUPTIBLE)。这段逻辑在static int ep_poll(struct eventpoll *ep, struct epoll_event __user *events, int maxevents, long timeout)中，第1494行。

如果监听的文件开启的是边沿触发(默认)，则不会执行上图中的list_add_tail()逻辑。这就是边沿触发只会向用户报告一次，直到下一个关心事件发生才向用户空间报告的原因。

那么为什么ET触发效率高于LT触发呢？看一个例子，假如客户端监视一个TCP的Socket，服务端这时发来1M数据，客户端的主机网卡驱动缓存足够大，一次性接收到了所有1M数据。下面看两段客户端的接收伪代码(没有写read调用返回时socket被关闭的情况；另socket描述符fd被设为非阻塞)。

上图的代码使用了LT触发，这段代码依赖epoll_wait()通知还有数据可供读取。所以共调用了1024次epoll_wait()，1024次read()，共2048次系统调用才读完1M数据。

上图使用ET触发，epoll_wait()只报告一次，然后代码循环调用1024次read()读完数据，直到第1025次read()返回-1，出错码为EAGAIN(EAGAIN等于EWOULDBLOCK)，于是代码知道已经接收完数据。一共只使用了1026次系统调用就读完了数据。

总结：即使使用电平触发也不要依赖epoll_wait()通知调用者到达事件，需要循环调用IO函数直到被通知EAGAIN，这样就把epoll_wait()的调用次数降到最低，仅管有可能在下次epoll_wait()时会有可能浪费一次文件的poll()调用，但这个很小的开销可以忽略。

二. 为什么epoll支持嵌套调用

读epoll的实现代码发现，一个epoll的文件描述符epfd可以嵌套的加入另一个epoll。这样有什么用呢？

epoll的实现中“平等的”对待每个被监视的文件，它们维护在一棵红黑树之中，假如有十万个文件被监视，那么查找某个文件时就要在这十万个文件中查找。即使红黑树的查找效率是log(n)，文件非常大时也是比较消耗时间的。

那么假如有这样一种情况，如果这十万个文件中只有1000个是活跃的，或者说这1000个文件优先级最高。那么则有一种优化方案是，创建两个epoll，第一个epoll（epfd0）监控100000 – 1000 个文件，第二个epoll (epfd1) 监控1000个高优先级文件以及epfd0。这样的好处是，大多数情况下epoll实现只在1001个元素的红黑树中查找，自然效率提高了。

总结：epoll的嵌套调用给开发者提供了一个在高并发环境下的优化方案。

三. epoll的效率一定比select/poll高吗。

答案是不一定。

Select的缺点大致有：

1. 内核中写死了最多只能监视1024个文件.

2. 每次调用select都要把关心的文件描述符和关心的文件件从一个用户空间的长长的数组拷贝到内核空间.

3. select若使得caller进程进入睡眠后，某个文件有事件到达此进程被唤醒，那么所有被监视的文件全部会被调用poll()询问“你有没有事件到达”，这是一个线性的时间复杂度。

epoll针对select的三个缺点的改进：

1. 监视的文件数由取决于系统中有多少低端内存(x86_64架构中的所有内存都是低端内存)。3.9.6版本的内核实现中，对于每个登录用户，最多使用系统中低端内存的4%用来创建监视用的数据结构。见第1951行代码。max_user_watches = (((si.totalram – si.totalhigh) / 25) << PAGE_SHIFT) / EP_ITEM_COST;

2. 用户只需要把关心的文件对应的数据结构在调用epoll_wait()前用epoll_ctl()一次性传入内存，以后调用epoll_wait()时不需要像select一样拷贝大量数据。

3. 当调用epoll_wait()的caller进程睡眠时，突然有事件到达，caller进程被唤醒，epoll_wait()返回用户空间，内核并不遍历没有监视的文件，而只报告在一个即短时间内发生的事件。下面更详细的描述这个场景，以监视tcp socket举例，大致是：某进程调用epoll_wait()，此时没有任何它关心的事件发生，于是caller进程进入睡眠。处理器调度了其它进程。数据到达时，当前进程被硬件中断，网卡驱动收到数据包，数据包在中断处理函数中被拷入内核，中断处理函数设置中断下半部(Half Bottom)。下半部被处理器调度，调用epoll实现代码注册的回调函数ep_poll_callback()。ep_poll_callback()函数唤醒之前的caller进程，caller进程重新获得CPU，从epoll实现的ep_poll()函数中恢复执行，在3.9.6内核中的第1564行： if (!schedule_hrtimeout_range(to, slack, HRTIMER_MODE_ABS))。然后，内核代码开始收集已经就绪的文件和发生的事件，发回用户空间。只有从第一次回调函数ep_poll_callback()被驱动的代码调用（caller进程还在睡眠时执行的ep_poll_callback()算第一次）到epoll实现代码走到第586行关闭中断关闭中断的代码 spin_lock_irqsave(&ep->lock, flags);之间发生的事件才会被收集。

对于第3点，这是epoll的优点，但在某种情况下却会是epoll的缺点。网上很多比较poll, select, epoll性能的文章，没来得及仔细看，我个人认为结论是可靠的。结论引入了一个概念active-to-total ratio，设所有被监控的文件数是n，活跃的文件数是m，active-to-total比则是m/n，如果这个比非常高，比如大于0.7，则poll或select的性能要高过epoll，反之则epoll胜出。

对比前文对select的第3个缺点和epoll的改进点3的叙述可以解释这个原因。因为select在返回用户空间前又轮循了所有关心的文件，而这些文件又大部分是有事件发生的，所以select所做的工作并没有浪费，但epoll只收集了一小段时间中发生的事件，于是select较之epoll减少了用户空间和内核空间的频繁切换，从而让select的性能反超epoll。

那么如何改进呢？明白了以上的原因，那么就可以对epoll做出改进，理论上对于active-to-total比较高的应用环境下，可以在epoll的实现中加入与select做法相同逻辑，即退出前询问所有的监控文件，反正active-to-total比很高。或者更好的方案，用一个链表链接活跃的文件，在epoll返回用户空间前遍历这个链表，争取每一个epoll_wait()调用返回尽可能多的事件。

附：epoll的主要数据结构简介.

epoll接口的主要数据结构有struct eventpoll，struct epitem，struct eppoll_entry。

在讲述这三个数据结构前先提一下struct file。Unix设计初期希望它的设计遵从“一切皆文件”的理念。在Linux内核中，每个抽象的文件对应一个内核struct file结构体。Struct file结构体中有一个void *private_data域。不同的文件类型会在private_data域中存放特定的信息。Struct file中另一个域f_op是函数指针的列表，它记录了对应该文件的操作。所有epoll文件的f_op都指向static const struct file_operations eventpoll_fops，因此可以代码判断一个文件是不是epoll如下：

static inline int is_file_epoll(struct file *f)

{

return f->f_op == &eventpoll_fops;

}

每次成功调用epoll_create时就会创建一个struct file的结构体，和一个struct eventpoll。Struct file中的private_data指向struct eventpoll。eventpoll维护了这个epoll的重要信息。其中比较重要的几个字段有：一个循环列表struct list_head rdllist链接了该epll中已经可以读写或者有出错的文件描述符。一个红黑树的根结点struct rb_root rbr，eventpoll维护了一棵红黑树，树中的结点是struct epitem。

每个被加入到epoll中被关注的文件描述符都对应一个struct epitem结构体。所有加入到同一个epoll中对应的所有epitem都挂在红黑树上。该红黑树的根结构保存在struct eventpoll中。epitem中记录了对应的文件的文件描述符和文件指针。

struct eppoll_entry是用来挂接到设备文件中的结构体。设备驱动在得知自己可读或可写或有错误时通过这个结构体通知有事件发生。每个eppoll_entry都指向一个epitem，一个epitem可能对应多个eppoll_entry。eppoll_entry中的域wait_queue_t wait就是被用来挂接到设备文件中的等待队列。设备文件通过wait可以拿到eppoll_entry，再通过eppoll_entry拿到epitem，再拿到eventpoll。

makefile使cpp文件依赖头文件

Wed, 07 Aug 2013 12:00:10 +0000

读代码时发现目前工程中的makefile文件中有一个问题或bug，.即cpp文件没有和该.cpp文件include的头文件建立依赖性。这个危害是，当头文件被修改后，受影响的.cpp文件对应的.o文件不会被重新创建。

而目前的代码中大量使用C++模板，模板的实现全部写在.h文件中.

我做了个实验，修改了单件模板的实现文件 SingletonHolder.h。虽然这个修改影响了大量include了SingletonHolder.h的.cpp文件，但它们对应的.o全被没有被重新编译。

解决方法是用g++编译器提供的 -MM 选项。这个选项会让g++在把.cpp依赖的头文件(除系统头文件)全部列出来。具体的使用方法可以查阅手册。思路是，把cpp文件和头文件的依赖性写入到.d文件，在主makefile文件中include所有的.d文件。

以tcpd工程为列，修改后的makefile如下(亦见附件)，该makefile可以检查到.cpp依赖的头文件被修改，使得重新生成目标文件。

include ./makefile.def

SRCS = $(wildcard *.cpp)

OBJS = $(patsubst %.cpp,%.o,$(SRCS))

# 每个.cpp都对应一个.d文件，.d文件由g++ -MM生成，列出了.cpp依赖的头文件.

DEPENDENCIES = $(subst .cpp,.d,$(SRCS))

TARGET = tcpd

OK = [\e[1m\e32m OK [\em

FAILURE = [\e[1m\e31m FAILURE [\em

all:$(TARGET)

# 使包含.d文件，.d文件指定了.o文件依赖哪些头文件。

# 如果不是make clean 就include所有的.d文件。

ifneq “$(MAKECMDGOALS)” “clean”

-include $(DEPENDENCIES)

endif

# 此函数生成.d文件，参考g++的 -MM -MF -MT选项

#$(call make-depend,source-file,object-file,depend-file)

define make-depend

g++ -MM -MF $3 -MT $2 $(CXXFLAGS) $(CPPFLAGS) $(TARGET_ARCH) $1

Linux桌面环境下内存去重技术的研究与实现(第二章)

Tue, 04 Jun 2013 03:03:51 +0000

Linux桌面环境下内存去重技术的研究与实现

在这里可以下载原稿 www.ykyi.net/upload/Research_and_Implementation_of_Memory_Deduplication_in_the_Linux_Desktop_Environment.pdf

第二章相关理论与技术

2.1 内存管理

内存管理是操作系统内核中极为重要的部分，它涉及物理地址、虚拟地址、分段、分页等诸多概念。

2.1.1 内存地址

程序使用地址来访问内存单元。对于x86架构的中央处理器，使用逻辑地址，虚拟地址，物理地址三种不同的地址^[15]。

逻辑地址包括段和偏移地址两部分，它们共同用来指定机器指令或者操作数在内存中的位置。逻辑地址对应下文提到的分段式内存管理。

虚拟地址也被称作线性地址，它表示一个寻址空间。在Linux操作系统中，使用一个无符号长整型存储虚拟地址。如果是针对32位x86处理器的内核，这是一个32位的无符号长整型，可以寻址至多2³²，即4GB空间。而Linux在x86_64处理器上，一个无符号长整型有64位，但实际上只使用了48位，即可寻址到2⁴⁸ ，即256TB的内存空间。引入虚拟地址使得用户空间的进程都独自拥有一个地址空间，方便操作系统在硬件的协助下隔离进程访问内存的操作，从而实现更高的安全性和便捷性。在32位处理器架构下，4G虚拟地址空间划分成两部分，高端的1G空间被称之为内核空间，低端的3G空间称之为用户空间。内核的代码和数据存在内核空间，用户空间的进程通过系统调用陷入内核空间执行内核空间的代码。对于64位处理器，虚拟地址同样分为内核空间和用户空间，只是针对64位处理器的内核拥有大得多的寻址范围，对内核空间和用户空间的地址划分有多种实现。

物理地址被中央处理器用来寻址内存芯片上的实际的物理单元。它对应了送往处理器的针脚上的高低电平信号。

Linux中的内存管理单元 (Memory Management Unit, MMU)在硬件电路的帮助下把逻辑地址译成线性地址；而另一个硬件电路则帮助把线性地址翻译成物理地址。

2.1.2 段页式内存管理

内存分段是由80×86处理器引入的概念，它鼓励程序员在设计程序时把程序使用的内存按照逻辑上的意义相关性分成若干个部分，比如有些段存放全局数据，有些段存放程序代码^[16]。

内存管理单元的分页单元协助把虚拟地址译为物理地址，为了提高翻译的效率，虚拟地址被按照固定长度切分成一个个小单元，它们则被称之为页面。页面可以看成是MMU管理内存的最小单位。

分段和分页都用来划分内存，在某种程度上，它们的功能有一定重合。实际上，Linux内核的内存管理机制倾向于使用分页技术。Linux进程运行在用户空间时使用的标志代码段的代码段选择子(segmentation selector)和数据段选择子是相等的；进程运行在内核空间时使用的代码段选择子和数据段选择子也是相等的。而且这四个段选择子的段基址都设置为0。这意味着在Linux操作系统中，无论寻址数据和还是寻址指令，无论在用户空间还是内核空间，逻辑地址的段基址部分为0，偏移地址部分刚好等于虚拟地址。

在Linux所支持的大多数硬件平台上，默认的页面大小是4K。但Linux同时也支持大于4K的页面的内存管理。运行在用户空间的代码可以使用glibc库中的getpagesize()函数得到当前使用的页面大小。本论文只针对在x86_64架构上页面大小是4K的Linux内核。实际上从内核2.6.38开始，内核中开始支持透明巨页(Transparent Huge Page)^[17]，内核中有些页面的大小实际上是2M，但这不影响按照4K的页面大小展开讨论。

Linux使用分级页表的方式把虚拟地址映射到页面。在32位处理器上使用二级页表，在x86_64架构的处理器上则使用四级页表。

图2-1 四级页表

如图2-1所示，以针对x86_64架构处理器的Linux内核为例，64位虚拟地址的高16位不被使用，低48位被平均分为5段，offset段占12位，其它四个段各占9位。这个划分在源代码文件arch/x86/include/asm/pgtable_64_types.h中定义。cr3寄存器存储了页全局目录的物理地址。在把虚拟地址翻译到物理地址的过程中，MMU先从cr3寄存器中取出全局目录的物理地址，再加上GLOBALDIR段算出的偏移量，从而在页全局目录中得到页上级目录的物理地址。与此类似，从页上级目录中得到页中间目录的地址，然后得到页表的地址，再得到页面的地址，最后的OFFSET字段则定位到页面中的一个字节。至此，虚拟地址被翻译到了物理地址。

页全局目录，页上级目录，页中间目录，以及页表中的每一项都由相同的数据结构表示。它记载了一些重要的信息，与本论文相关的信息有：该项指向的下一级表或者页面是否存在的标志，如果访问时不存在则产生缺页中断，由do_page_fault函数负责把页面调入内存^[18]；下一级表或页面的物理地址；下一级表或页面是否可读可写的标志，利用该标志位可以写保护一个页面。

Linux内核用一个struct page结构体描述一个页面的信息。这个结构体定义在include/linux/mm_types.h文件中^[19]。图2-2列出这个结构体中与本论文直接相关的字段。

图2-2 struct page的部分字段

其中的flags字段存储了页面的状态信息，例如：表示页面刚被写了数据的脏位；该页面是否被锁定在内存中不充许置换到交换分区的标志。_count字段和_mapcount字段都是引用计数，它们用来共同维护page页面的生命期。_mapcount表示一个页面拥有多少页表项指向它，_count被称为page的使用计数，所有的_mapcount计数只相当于_count计数中的一次计数。如果内核代码中某执行序列在访问某个页面时需要确保该页面存在，则在访问前给_count计数加一，访问结束后_count计数减一。当_count计数减到负数时表示没有任何内核需要使用该页面，则表示该页面没被使用。内核代码不应该直接访问_count计数，而应该使用page_count函数。该函数用一个struct page的指针做为参数，当该页空闲时函数返回0，否则返回一个正数表示参数指向的页面正被使用。当页面被页高速缓冲使用时，mapping域指向一个address_space对象，该对象与Linux文件系统中的文件是一对一映射的关系，描述了一个文件分配到的物理页面及相关数据结构。如果页面并不被页高速缓冲使用时，mapping则有其它的意义，比如mapping字段的最低位记载这是否是一个匿名页面。virtual字段是映射到该页面的内核空间的虚拟地址，如果该页面是属于高端内存区域则virtual字段为NULL。对于x86_64架构上的Linux内核，已经没有高端内存，因此该字段不会为NULL。

2.1.3 内核中的巨页

现代处理器的内存管理单元几乎都能处理除4KB大小外的多种页面尺寸。然而，Linux内核在几乎所以平台上的实现都选用最小的页面大小，即4KB，比4KB更大的页面，都被称之为巨页(huge page)。在某些工作环境下，巨页可以给操作系统带来性能上的提高。巨页能提高操作系统的性能主要是因为两点。第一，使用巨页可以减少发生页面出错处理的频率，因为在每次页面出错处理时内核调入比使用小页面更多的内存。第二，使用巨页减少翻译虚拟地址的时间。在x86_64加构的处理器上，从虚拟地址翻译到物理地理需要依次访问四级页表，非常耗时。而使用巨页可以减少页表的级数。实际上更大的性能提高源自使用巨页后提高了旁路转换缓冲区(Translation Lookaside Buffer，TLB)的命中效率^[20]。

在内核2.6.38版本之前，唯一使用巨页的方式是通过非常复杂的hugetlbfs文件系统。应用程序开发者和系统管理员都需要注意一些特别事项才能够开启巨页功能。因此只有极少数真正需要巨页带来性能提高的用户，如专用数据库系统，才使用巨页。

情况从内核版本2.6.38以后发生了变化，一个被称之为透明巨页的功能被合并进了内核主干代码。之前内核在VMA（Virtual Memory Area，虚拟内存区域）中的所有页面大小都是一样大的，而加入透明巨页后，VMA中的页面的大小可能不只一种。透明巨页的实现代码改写了页面出错处理函数，当一个出错发生时，内核尽力分配一个巨页，如果成功的话，其它相应的在巨页地址范围内的小页面就会被释放，巨页被插入到VMA中。如果不能分配到一个巨页，则仍然按照以前的方式分配一个小页面。当巨页需要被置换到交换分区时，透明巨页机制简单地把巨页切割成小页面，其它逻辑和处理小页面时一样。实际上不仅在置换到交换分区时需要切割巨页，很多其它的操作，如mprotect()和mlock()页面时也需要。本论文将详述的KSM在合并页面时同样需要把巨页切割成小页面。

透明巨页这种轻便地利用巨页的方式使得很多内核代码并没有感知到巨页的存在，对于应用程序则更没有感知到巨页，因此被称之为透明巨页。

2.1.4 内存描述符

Linux内核使用一个叫内存描述符(Memory Descriptor)的结构体描述每一个进程的地址空间^[21]。这个结构体包括了所有和进程地址空间相关的信息。内存描述符和struct page一样在文件include/linux/mm_types.h中定义。图2-3列出这个结构体中与本论文直接相关的字段。

图2-3 struct mm_struct的部分字段

其中，mmap字段是用来实现一个链表。这个链表链接了属于这个内存描述符的所有vm_area_struct结构体。vm_area_struct结构体描述了一个内存区域。由于属于一个内存描述符的内存区域可能非常多，为了加快内存区域的查找以及添加删除等操作的速度，内核用mm_rb表示一棵链接了所有内存区域的红黑树。红黑树是一种二叉树，它被广泛地应用在Linux内核代码中。mmap和mm_rb是用两种不同的数据结构表示同一批数据。mm_users和mm_count是内存描述符的引用计数，它的实现原理和struct page的引用计数的原理一样。每一个进程如果拥有一个内存描述符，则会增加mm_users的计数，所有mm_users的计数只相当于mm_count的一个计数。比如n个Linux线程共享同一个内存描述符，那么对应的内存描述符的mm_users计数则为n，而mm_count则可能只是1。如果有内核执行序列想要访问一个内存描述符，则该执行序列先增加mm_count的计数，使用结束后减少mm_count的计数。一但mm_count减为0，表示该内存描述符没有任何引用，则它会被内核销毁。mmap_sem是一个读写锁，凡是需要操作内存描述符中的内存区域时，则需要先得到相应的读锁或者写锁，使用结束后释放该锁。mm_list字段是一个循环双链表。它链接了系统中所有的内存描述符。flags字段定义了内存描述符的标志，这些标志标记了内存描述符的一些状态和属性，内核代码需要使用原子操作访问该字段。

2.1.5 虚拟内存区域

同样被定义在inlude/linux/mm_types.h中的结构体vm_area_struct用来描述一个内存区域。在Linux内核中，内存区域经常被称之为虚拟内存区域(Virtual Memory Areas,VMA)。VMA描述的内存区域是一个地址空间中的地址连续的部分。而且该部分拥有一些特定的属性，比如访问权限和相关联的操作等。不同的VMA可以用来描述不同的内存区域。比如，映射到内存的文件，用户空间的栈，特别是本论文重点关注的匿名内存区域(Anonymous VMA)。下面讨论本论文关心的vm_area_struct的一些重要字段，这些字段如图2-4所示。

Linux桌面环境下内存去重技术的研究与实现(第一章)

Sat, 01 Jun 2013 09:00:14 +0000

Linux桌面环境下内存去重技术的研究与实现

在这里可以下载原稿 https://as.goodas.gold/Research_and_Implementation_of_Memory_Deduplication_in_the_Linux_Desktop_Environment.pdf

第一章绪论

1.1 课题背景

内存是操作系统中最为重要的资源之一。为了最有效地利用好有限的内存资源，现代操作系统使用了很多技术以节省内存的使用。在Linux程序的内存布局中，代码段具有只读属性，永远是共享的。具体地说，即使一个程序被实例化了多个进程，但是在物理内存中对于该程序的代码只有一份拷贝，同一个程序的不同进程之间共享这份拷贝。而且，所有共享库（Windows下被称之为动态链接库）的代码段在物理内存中也只有一份拷贝^[1]，所有加载了该共享库的进程虽然把共享库加载到了不同的虚拟地址中，但实际上都映射到相同的物理地址上以实现对共享库代码区的共享。除了共享只读的代码区外，可写的页面也可能在进程之间被共享，Linux在创建进程时的fork操作使用写时拷贝技术在父子进程之间共享内存。当父进程调用fork()函数后，所有的可写页面转成写时拷贝页面。只要父子进程都不写入某页面，则该页面一直被共享。

近年来，Linux操作系统中出现了一种新的节省内存的技术，它的出现源于云计算的发展。云计算能够通过互联网按需分发计算机的软硬件资源，被称之为IT产业的又一次革命^[2]。虚拟机技术是云计算的基础，Xen和KVM(Kernel Virtual Machine，内核虚拟机)是开源社区最流行的两种虚拟化技术^[3]。通过运用虚拟化技术，越来越多的Linux主机上同时运行着多个虚拟机，而虚拟机使用了相同的操作系统，操作系统中运行着相同的大型程序，如数据库服务器，邮件服务器，Web服务器等。在运行多个虚拟机的环境下，人们发现虚拟机之间存在着大量的相同内存页面，但Linux主机没有办法共享这些内存页面。为了解决虚拟机之间大量重复内存的问题，Linux社区诞生了KSM(Kernel Samepage Merging，内核相同页面合并)技术。KSM技术通过扫描内存区域，找到相同的内存页面，并把它们合并。该技术使得运行虚拟机的主机使用的内存明显下降，从而让同样的Linux主机在使用KSM技术后能运行更多的虚拟机。

KSM技术虽然是为基于KVM技术的虚拟机设计，但也能运用到普通的桌面应用程序。随着软硬件技术的不断进步，Linux桌面应用程序占用的内存也越来越多。普通的Linux桌面应用程序中存在多少重复页面，重复页面的分布有些什么特点，把KSM技术运用在桌面应用程序上存在什么问题，这些是本论文将要探讨的内容。针对桌面应用程序的重复内存，本文在KSM的基础上开发了KSM+，能方便有效地合并桌面应用程序的重复内存。

1.2 国内外研究现状

对于传统的节约内存技术，如共享只读代码区，fork的写时拷贝技术。这些技术非常成熟，现代操作系统中已经普通采用。

另外，文献^[4]研究了一种比较特殊的节省内存技术。它针对的是科学计算中的特殊程序，通过用注释驱动的工具把源代码转译到更高效的代码，于是编译出节省内存的程序。

近年来研究较多的是基于合并相同内存页面的内存去重技术：通过查找系统中的相同内存页面，把这些页面合并从而节省系统内存。但国内外的研究基本集中在运行虚拟机的场景中。如VMware公司较早进行了虚拟机内存去重技术的研究工作，文献^[5]研究了VMware公司的Hypervisor(虚拟机管理器)使用的基于合并相同内容内存页面的去重技术，以减少虚拟机之间的内存冗余。文献^[6]详细论述了此类技术对于基于Xen的虚拟机的实现。Linux社区的类似技术称之为KSM。文献^[7]以实证研究的方式通过大量实验研究了KSM用于合并虚拟机之间冗余内存的性能。文献^[8]研究的是在数据中心中如何提高在虚拟机之间合并相同内存的效率。它实现了通过把虚拟机在各物理机中动态迁移到最适合的位置从而提高合并效率。文献^[9]使用KSM技术解决了主机和虚拟机都需要维护自己的缓存的问题，提高了缓存的效率。KSM技术并不是总能高效地去除虚拟机之间的冗余内存，也存在一些问题。内存地址的ASLR(Address Space Layout Randomization，空间布局随机化技术)是为了提高程序安全性的一种技术。该技术提高了程序的安全性，却影响了页面对齐，从而影响了KSM的合并效率^[10]。另外，KSM的运用也暴露了安全问题。运行在某台虚拟机上的程序可以通过构造特定的页面尝试让主机的KSM合并它，再计算写该页面所用的时间。因为写被KSM合并的页面的时候会发生写时拷贝，所以这个时间会比正常情况下延迟。通过利用这个时间差，运行在一台虚拟机上的程序可能会发现其它虚拟机上运行的程序^[11]，甚至让虚拟机之间秘密通信^[12]。

KSM技术应用在非虚拟机的场景下的研究则比较少。欧洲核子研究组织(CERN)的核子实验模拟程序产生海量的数据，并且并行工作的科学程序同时载入这些数据，使得内存中有大量的相同内容页面。CERN通过使用钩子技术修改C运行库的malloc()从而运行KSM，解决了内存中的大量重复页面的问题，节省了8%-48%的内存^[13]。

本论文将在一般桌面应用环境下研究并增强新的内存节省技术KSM，使之更适合运用在桌面应用环境下，更有效地减少应用程序的内存使用量。

1.3 研究意义

内存资源总是操作系统中稀缺的资源，研究节省内存的技术具有普遍的意义。另外，随着基于Linux内核的操作系统如Android在消费电子终端上的迅速普及^[14]，以及可预见到基于Linux的Chrome OS在PC桌面市场也将占有一定市场，而目前的应用程序普遍占用越来越多的内存，研究Linux平台下新的节省内存的技术KSM，对于开发Android平台等基于Linux内核的平台下的商用优化管理软件具有重要的技术指导作用。

1.4 论文的主要工作

本论文重点研究了Linux内核的KSM模块的设计与实现，并在原来的基础上做了针对桌面应用环境的增强与改进，同时认真研究了Linux内核代码的组织方式，配置与编译方式，内核开发及调试的技术，以及Linux的内存管理单元的实现。增强后的KSM命名为KSM+,它比原来的KSM更方便地自动采集到应用程序的相同内容页面并合并这些页面，以达到节省应用程序消耗的内存的目的。论文用多个实验展示了KSM+的功能，并与修改前的KSM做了比较。此外，本论文还编写了内核模块用于统计Linux桌面应用程序的重复内存页面的特点，同时可以用来应证KSM+运行的效果。

1.5 论文的整体结构布局

本论文的第二章介绍了x86体系的段页式内存管理方式，以及Linux的内存管理的实现，还介绍了编写Linux内核代码的一些基本理论。

第三章介绍了如何使用KSM以及KSM的设计和实现原理。

第四章讲述KSM+的设计与实现。KSM+是在KSM的基础上的增强与改进。

第五章用多个实验展示了KSM+合并程序的重复内存页面的效果，并设计了一个实验比较了KSM和KSM+的差别。最后编写了用于统计应用程序重复内存页面的内核模块，并用统计数据应证了KSM+的实验结果。这些统计数据反映了Linux桌面应用程序中重复内存页面的一些基本特点，对进一步改进KSM+的算法提供了依据。

1.6 本章小结

本章首先介绍了Linux操作系统中传统的节省内存技术，然后引入了因为虚拟化兴起而发展的新的内存节省技术，它通过合并内容相同的内存页面从而减少系统的内存使用，也被称之为内存去重技术，接着叙述了国内外在该技术方面的相关研究。目前对该技术的研究多针对虚拟机环境，而本论文则是在Linux桌面环境中研究内存去重技术。

Linux桌面环境下内存去重技术的研究与实现(中英文摘要)

Mon, 27 May 2013 14:28:12 +0000

Linux桌面环境下内存去重技术的研究与实现

在这里可以下载原稿 www.ykyi.net/upload/Research_and_Implementation_of_Memory_Deduplication_in_the_Linux_Desktop_Environment.pdf

论文题目： Linux桌面环境下内存去重技术的研究与实现

专业：软件工程

硕士生：周霄

指导教师：王常吉

摘要

**关键词：**KSM，重复内存合并，内存管理

Title: Research and Implementation of Memory Deduplication in The Linux Desktop Environment

Major: Software Engineering

Name: Zhou Xiao

Supervisor: Wang Changji

Abstract

SAN和NAS有什么区别和相同

Mon, 29 Apr 2013 07:55:45 +0000

SAN(Storage Area Network存储区域网络)和NAS(Network Attached Storage不知中文点译)都是提供网络存储的解决方案。

其中NAS是*一个*存储设备，以文件为操作单位。

SAN用一个局域网把很多设备连接起来，以磁盘的块(block)为操作单位。

我的BUG大全。

Sat, 23 Mar 2013 03:32:22 +0000

在这里记下我的程序BUG

buff溢出后，把栈破坏了，这个线程也没崩溃，一直死循环在一小段不可知的代码里。

#调用getaddrinfo很多次以后，getaddrinfo报错：No address associated with NAME。非常地奇怪呀后来把同样的程序部署到比较旧的linux上，报错: Too many open files。才明白，原来fd被用光了。回头再检查相关代码，果然如此~补上close(fd)后，getaddrinfo的问题也解决了。启发是：1. 有些报错信息其实离真正的错误原因很远。2. 一个系统调用一开始正常，跑了很多次后失败，应该怀疑是不是有资源泄露。

#把uint_t类型赋值给std::string时，会崩溃在std::string里面。

#当一个预期统一的规则出现特例的时候容易出现BUG. 关联订单，关联片区，入货地址都指受YYYY-MM-DD HH:MM:SS的时间戳，但同机分析接受的时间戳却是YYYYMMDD某一天的时间戳。有一个组合需求是同时导出上述4个小需求时，由于传入的时间戳参数不一致导致了BUG.

vector::push_back可能会重新分配vector的内存，导致指向之前元素的引用和指针失效.一个std::function持有一个std::ref指向vector中的一个元素，当这个funcction被调用的时候，vector中的这个元素已经失效了。

# 用boost::optional记录一个信息。这个信息没及时在clear函数里做清理。于是，观察到的情况时，这个信息总是被打印。但一开始，我们却怀疑是另外的函数不稳定而重新生成了该信息。

在写一个匹配函数时，待匹配操作数是一个字符串，我没有考虑字符串是空串的情况。

在比较旧的gcc 4.1.2上把shared_ptr赋给 weak_ptr时，崩溃。溃在atomic_exchange_and_add。一开始怀疑是旧版gcc对boost的智能指针支持的不够好，后来发现是因为weak_ptr此时已经失效了。原因是用handler的参数持用shared_ptr的引用做生命期管理时，传错了参数，使得这个对象已经被销毁了。

现象：一个依赖某布尔变量的逻辑大多数时候正常，少部分时间异常。期望这个布尔变量是false，有时候陌名其妙变成了true。

原因是此布尔变量未被初始化，大多数时候它的值是false，但有时却不是。

#. 现象rmap_item泄露.

Fix it: 单链表插入新结点时指针操作出错。应该是new->rmap_list = _item，被我写成 new->rmap_list = (_item)->rmap_list.

#. 我意图注释掉某行代码，却鬼使神差注释错了一行代码。

#. 变量名 pkt 和ptr 很像，在用memcpy函数时用错了变量导致bug. 一块内存被莫名其妙的修改了，很有可能是因为像刚才这样写这块函数的参数填错了。

#. _sessions.erase(ite++);删除了_sessions维护的一个对象.对象的析构被调用，会有一连串对象的析构因此而被调用。这些对象中的指针很可能就失效了。但是，在代码的其它地方还能拿到这个指针。野指针啊！！！今天这个例子中是session维护的ip_pkt对象都被析构了，ip_pkt中的指针也都失效了。于是，一使用野指针，崩溃了。

#. 删除数据时，总是要注意其它代码中指向这些被删除数据的引用或指针。

#. 解引用container.end()返回的迭代器会崩溃。

#. 这是个腾讯视频广告投放组的bug. 一个线程负责开，关FD。另一个线程读写FD。两个线程的竞争条件造成了BUG.

#. 写代码时偷懒复制代码，然后忘记做相应更改，视觉上很难在第一时间察觉，却在后期花费了几倍时间调试程序。

#. 写判断语句时，判断表达示如 container.empty()之前是否要取反，经常搞错。

#. htonl 写成 htons

#. std::distance 计算两个迭代器之间距离时死循环，是因为迭代器没有初始化。而我之前想，作初始化工作的函数已经调用了，实际上并没有被调用。

#. 没注意函数的返回值. 有时函数返回0时表示成功，即true的含义。所以看到一些和预期刚好相反的现象时，应该考虑是不是出现了这样的错误。

泪流满面，WARNING: modpost: Found 1 section mismatch(es).

Thu, 28 Feb 2013 02:02:31 +0000

看来编译时出现警告要非常重视，一定要对警告的意义非常清楚，这极可能是出现BUG的原因。

昨天调了一整个晚上，各种离奇的出错~~

其实编译内核模块时，已经提示我警告了，但我一直没注意：

Building modules, stage 2.
MODPOST 1 modules
WARNING: modpost: Found 1 section mismatch(es).
To see full details build your kernel with:
‘make CONFIG_DEBUG_SECTION_MISMATCH=y’
CC /home/zausiu/linux-3.0.66/mm/sksm/sksm.mod.o
LD [M] /home/zausiu/linux-3.0.66/mm/sksm/sksm.ko

警告告诉我使用 ‘make CONFIG_DEBUG_SECTION_MISMATCH=y’

我以为要编译整棵kenel sourcecode tree时打开DEBUG_SECTION_MISMATCH编译选项，在我的虚机里编译一次要几个小时啊，果断拒绝了。其实在内核代码树外单独编译内核模块时也只用DEBUG_SECTION_MISMATCH=y这个选项。

# make DEBUG_SECTION_MISMATCH=y

…

Building modules, stage 2.
MODPOST 1 modules
WARNING: /home/zausiu/linux-3.0.66/mm/sksm/sksm.o(.init.text+0x193): Section mismatch in reference from the function init_module() to the function .exit.text:sksm_slab_free()
The function __init init_module() references
a function __exit sksm_slab_free().
This is often seen when error handling in the init function
uses functionality in the exit path.
The fix is often to remove the __exit annotation of
sksm_slab_free() so it may be used outside an exit section.

dpkg的一些用法

Mon, 25 Feb 2013 02:28:11 +0000

Debian的dpkg的一些用法

<p>
  &nbsp;
</p></p>

1. 查看当前系统中的软件信息(dpkg -l)

"dpkg -l"命令用于查看当前系统中所有deb的软件包信息；通过"dpkg -l"命令与less和grep命令配合使用，可以实现更复杂的软件包信息查询功能。

debian:~/Desktop# dpkg -l

期望状态=未知(u)/安装(i)/删除(r )/清除(p)/保持(h)

| 当前状态=未(n)/已安装(i)/仅存配置(c )/仅解压缩(U)/配置失败(F)/不完全安装(H)

|/ 错误？=(无)/保持(?)/须重装(R )/两者兼有(#) (状态，错误：大写=故障)

||/ 名称版本简介

一位高手写的山东莱芜方言高频词汇

Wed, 20 Feb 2013 04:33:43 +0000

山东莱芜方言高频词汇

作者：高龙超 gaolch001@163.com

一、人称代词：

惩（音“恩”，ŋən）：你，你们

俺（ŋan）：我，我们

他（音近“特”，tə）：他

二、时间名词：

1、日子

夜来：昨天

今（音“机”，tɕi）们：今天

明日：明天

后日：后天

大后日：大后天

2、早晚

早晨：早上

头晌午：上午

晌午：中午

光午：为“过晌午”的连读，意为下午

后晌：晌（音“赏”，sŋ）亦常读作航（hɔŋ）

3、时钟

钟头：小时

不大霎（音“杀”，sa）：一会儿，不多时候，不长时间

大盼（pan）子：一大会儿，不超过半日

大会子：过了好久，一般指数月

三、动词：

1、与“家”有关

“家”作副词，表示动作的方向，该方向一般指自己的家。

家来：表示往“家”的方向而来，一般用来邀请其他人进入自己家

家去：表示往“家”的方向而去，“去”一般读作“气”，tɕʻi

家走：表示往“家”的方向而走，与“家去”相近，但“家走”更用来强调动作。

2、给（音“及”，tɕi）

表示“很”的程度副词：

（1）“精”，形容“小”及相近的词：

精短精细精窄精矮（音近“眼”，iai）精浅精薄精瘦

该组多用ABB式叠词，比如“精短”可以说“精短短”

（2）“大”，形容“大”及相近的词：

大长大粗大厚（该组多用ABB式叠词）

（3）“乔”含有让人难以忍受的意思。

乔冷、乔热、乔苦、乔脏、乔酸、乔硬、乔辣、乔臭、乔难受、乔不得劲、乔肚子疼。

（4）“详”，多有赞叹之意

详肥、详瘦、详干净、详富、详好。

（5）“怪”，它的语用域很广，只要普通话中能和副词“很”结合的词都能和“怪”结合。

怪沉、怪香、怪高、怪痛快、怪好

（6）“忒”，近似于普通话的“太”，一般表示程度有点过。

忒大、忒小、忒酸、忒甜、忒干净、忒窝囊

（7）“挺”，一般只能修饰“湿”和“浓”（泥泞）。

（8）其他固定搭配副词

焦酸焦黄焦干焦劲齁咸稀甜稀烂稀软

锃明锃白锃绿乌黑红黑齁辣

四、发音特点

1、声母：

（1）普通话的zh，ch，sh，r基本上读成平舌音z，c，s，？，普通话的z，c，s基本上读成咬舌音？，θ，？。

普通话的w声母大都读成唇齿音v。

（2）后面接u, ə时，部分r声母读成l

容（音“龙”）luŋ ，褥（音“陆”）lu ，乳（音“鲁”）lu ，软（音“卵”）luan

（3）普通话的零声母基本全部改为ŋ声母

俺ŋan，爱 ŋai，摁 ŋen ，袄 ŋɔ

2、韵母：

（1）以下字均为ei （近-ik）作为韵母：

得 dei 德 dei 客 kei 责 zei 白 bei 百 bei 色 sei 麦 mei 摘 zei 册 cei 策 cei 墨 mei 脉 mei 宅 zei 迫 pei 柏 bei 拍 pei 窄 zei 刻kei 塞 θei

（2）以下字均以-uə结尾：

药（音“约”）iuə 薄buə 脚tɕuə 博buə 钥（音“月”）iuə 着zuə 勺suə

（3）前后鼻音与普通话不同的字：

怎 dzəng

暖 nang

懂 dun

甭 bən

吗 mang

嘛 man

吧 bə

(4)了

句中用lɔ（唠）,句尾用liə（咧）。

五、其他习惯：

1、一般不用“死”字，普通话中有“死”这的，一般有“煞”（音“舌”，sa）。如：

气煞我咧：气死我了

喜煞我咧：笑死我了

冻煞咧：冻死了

关煞门：关死门（即：关上门）

2、普通话的“亮”一般改用“明”

明天了：天亮了

月明：月亮

锃明：锃亮

明快：明亮

GCC内联汇编写的memcmp函数 for x86-64

Sun, 17 Feb 2013 12:32:07 +0000

今天写内核代码时要写一个比较两个页框(Page Frame)的函数，想到用内联汇编来写这个功能。下面是代码：

long cmp_x64(void *s1, void *s2, size_t n)
{
size_t num = n / 8;
register long res;

   __asm__ __volatile__
   (
   “testq %3,%3\n\t” ; 测试num是不是0
   “repe cmpsq\n\t” ; 不停地比较直到cx寄存器为0或比较到差别
   “je 1f\n\t” ; 两块内存相等，跳出，返回0.
   “sbbq %0,%0\n\t” ; sbb是x86的减法指令，会额外地减去CF(借位)的值，这样%0就会是0或者-1
   “orq $1,%0\n” ; 把立即数1或到%0上，这样%0就会是1或者-1.
   “1:”
: “=&a”(res) ; 传入变量res放入寄存器ax，且这个变量是输出值(=)，不要与其它输入输出共用寄存器(&)
   : “0”(res), “S”(s1), “D”(s2), “c”(num) ; 输入列表
   : “cc”); // clobber list 告诉gcc在这段内联汇编中哪些寄存器被显式/隐式修改.If our instruction can alter the condition code register, we have to add “cc” to the list of clobbered registers.

Linux内核中的宏可变参数(GCC的宏可变参数)

Sun, 17 Feb 2013 05:10:42 +0000

Linux内核中的宏可变参数(GCC的宏可变参数)。
写内核模块的时候为了调试方便，经常需要wrap一下printk函数。下面的宏定义非常有实用价值。
注意两个井号~~
记到博客里~~

#define seclvl_printk(verb, type, fmt, arg...)			\
	do {							\
		if (verbosity >= verb) {			\
			static unsigned long _prior;		\
			unsigned long _now = jiffies;		\
			if ((_now - _prior) > HZ) {		\
				printk(type "%s: %s: " fmt,	\
					MY_NAME, __FUNCTION__ ,	\
					## arg);		\
				_prior = _now;			\
			}					\
		}						\
	} while (0)

今天用Debian时总遇到locale的错误.

Thu, 14 Feb 2013 13:59:56 +0000

我的debian一般把LC_ALL设成en_US.UTF-8。这次dpkg-reconfigure locales时没有选美国英语，而是用了香港英语。于是就出错了。

解决方法的关键在于 /etc/environment 文件, dpkg-reconfigure locales 命令用来配置local，以及locale命令列出当前期待的locale，还有 local-gen 命令可以生成local.

debian报得错误类似于：

perl: warning: Setting locale failed.
perl: warning: Please check that your locale settings:
   LANGUAGE = “en_US:en”,
   LC_ALL = (unset),
   LANG = “en_US”
are supported and installed on your system.

////////////

另外今天还解决了编译内核后，用新内核启动时报错：

kernel panic – not syncing VFS: unable to mount root fs on unknown block (0, 0)

// 通常这是因为对应文件系统被编译成模块，那么就应该生成initrd加载对应的文件驱动模块。在debian下，用update-initramfs 命令生成对应的initrd. 如： update-initramfs -c -k 3.0.63

git的排错神器pickaxe和git blame

Tue, 29 Jan 2013 08:30:03 +0000

git log -Sstring 这里的-S选项被称作pickaxe，这是一个非常好的排错工具。

比如： git log -Sinclude –pretty=oneline –abbrev-commit init/version.c

会把减少了，或者增加了include的commit全部找出来。

要注意的是，如果有一个提交增加和减少include的次数一样，这个commit不会被列出来。

/////////////

另外一个排错工作是 git blame:

git blame可以用来帮助查找引入bug的commit。git blame告诉你谁，什么时候，是哪个commit更改了某个文件。

如: git blame -L 32, init/version.c

使用gdb和虚拟机调试内核

Mon, 28 Jan 2013 03:31:28 +0000

调试内核很麻烦，即使是有了虚拟机的帮助。在这里记下一些关键的东西，以备忘。

＃编译内核后，用新内核启动系统失败，报错 “unable to mount fs ….” 之类.

需要用 update-initramfs 生成initram。

＃对于grub2，我增加了一个自定义的grub开机启动项用来调试内核，如下：

#!/bin/sh
exec tail -n +3 $0
# This file provides an easy way to add custom menu entries. Simply type the
# menu entries you want to add after this comment. Be careful not to change
# the ’exec tail’ line above.
echo “Add Debugging entry”
cat « EOF
menuentry “Debian debug 3.7.4”{
set root=(hd0,1)
linux /boot/vmlinuz-3.7.4 root=/dev/vda1 ro quiet kgdboc=ttyS0,115200 kgdbwait
initrd /boot/initrd.img-3.7.4
}
EOF

尼玛，原来用财富通转账比用支付宝便宜。

Wed, 23 Jan 2013 06:04:43 +0000

今天我哥们要我给打他些钱。

于是我就想到用支付宝试试，但哥也还有财富通的账号呀~~于是比较了两个支付平台的收费标准。

这是财富通的：

到账时间    服务费率真   手续费下限    手续费上限
次日到账    0.1%          1元/笔            10元/笔
2小时到账 0.25%          1元/笔            50元/笔

这是支付宝的：

  <th>
    到账时间
  </th>
  
  <th>
    服务费率
  </th>
  
  <th>
    服务费下限
  </th>
  
  <th>
    服务费上限
  </th>
</tr>

<tr>
  <td rowspan="2">
    金账户会员<br /> <em style="margin-left:12px;">(7折)</em>
  </td>
  
  <td>
    次日到账
  </td>
  
  <td>
    0.175%
  </td>
  
  <td>
    0.9元/笔
  </td>
  
  <td>
    35元/笔
  </td>
</tr>

<tr>
  <td>
    2小时内到账
  </td>
  
  <td>
    0.35%
  </td>
  
  <td>
    1元/笔
  </td>
  
  <td>
    35元/笔
  </td>
</tr>

<tr>
  <td rowspan="2">
    普通会员
  </td>
  
  <td>
    次日到账
  </td>
  
  <td>
    0.25%
  </td>
  
  <td>
    0.9元/笔
  </td>
  
  <td>
    50元/笔
  </td>
</tr>

<tr>
  <td>
    2小时内到账
  </td>
  
  <td>
    0.5%
  </td>
  
  <td>
    1元/笔
  </td>
  
  <td>
    <p>
      50元/笔
    </p>
  </td>
</tr>

收费标准：
用户类型

Okular是linux下最好用的pdf阅读工具

Fri, 04 Jan 2013 12:55:46 +0000

我记得对于大多数Gnome桌面环境，Evince是默认的pdf阅读软件。今天不知道怎么回事，发现evince没有了。当时我不记得evince这个名字了，就apt-cache search pdf 随便装上了xpdf-viewer。太他妈难用了啊～～就卸载了，然后google: The Best PDF Viewer on Linux。找到了Okular，也是免费软件，装上一用。不错哈哈哈.贴一张网络上的图片：

另外今天才知道, Adobe也有出linux下的pdf阅读软件。

显示Gnome3任务栏

Thu, 03 Jan 2013 09:22:54 +0000

Gnome3桌面较之Gnome2有了非常大的区别～

第一眼看上去有惊艳的感觉～多用了一点时间，发现没有任务栏真是相当的不方便啊。我觉得最方便的还是Win7的方式。

那怎么把Gnome3消失的任务栏找回来呢？通过安装一个安装包搞定。

我用的是Debian 6.06 Wheazy

zausiu@accolade:~$ cat /etc/debian_version
6.0.6

对于Debian家族的ubuntu应该也是适用的。

# apt-get install tint2

$ tint2 &

于是久违的gnome任务又回来了～

Gnome的任务栏又回来了

Let the Universal Access Preferences Taskbar Icon Disappear让统一访问首选项在任务栏上消失

Wed, 02 Jan 2013 05:45:27 +0000

我用的是Debian Wheezy Stable系统。今天不知道怎么搞得，把任务栏上面弄出个配置Universal Access Preferences的图标。右链点击也没有让我选择退出的选项。

搜索了一下，知道用 gnome-keyboard-properties 把这个该死的图标去掉。

alt+F2 输入 gnome-keyboard-properties
选中Accessibility ，取消 Accessibility features can be toggled with keyboard shortcuts.

这几天调linux内核源代码，好困难好困难。

2012年终总结预言2013

Sat, 15 Dec 2012 06:51:48 +0000

身为一只技术蝼蚁，我的2012是离奇又相当刺激的一年。这一年年初，我遇见了让我难忘的人，虽然结局非常悲惨；年中剑桥高级商务英语考试惨败与经历了时间最长的一次失眠症；下半年经历了找工作的惊心动魂又收获了惊喜；年尾写毕业论文比便秘还要艰难。

在互联网的战场上就更加刺激好玩~看看互联网的各派势怎么玩的

360：
战争之王周流氓继续发挥，打了三大战役。小三大战，在终端市场狙击以期货方式做互联网手机的小米军团；3B大战，继续挖掘客户端—浏览器—网址导流加搜索的三级火箭的商业模式，推出自营搜索引擎，挑战百度的垄断地位，直击百度的要害‘竞价排名’，揭露百度搜索引擎上医疗推广的暴利，从搜索市场上圈到了 10%的市场份额；还有方舟子和周总的大战，哈哈，这次算是棋缝对手啊。

sina:
新浪的微博在商业化的探索上继续苦苦挣扎。传统新浪网造血供给微博，微博继续烧钱，面对腾讯微博的防守和微信的进攻，资本市场惭惭对新浪微博失去信心。新浪已然失去掘起为 Baidu, Alibaba, Tencent 三大巨头同量级的大军阀的机会。

金山：
金山软件旗下的游戏和办公软件仍然波澜不惊。金山快盘拆分出来成立金山云计算公司，不知业绩怎样，个人觉得快盘还是满好用的，不过我已经改成用腾讯微云了。各大产商纷纷进入云存储领域，快盘若想有所作为也不那么容易。在傅胜的带领上，金山安全抢到了足够多的爆光率。金山安全年中推出猎豹浏览器，主打UI酷炫的特点，至此金山安全的的商业模式与360几乎一样。金山安全旗下软件的推广明显变得流氓起来。但，祝我的老东家走好。

百度：
百度面临360搜索的极大威胁，李彦宏呼吁百度员工的‘狼性’。如周鸿祎所说，百度缺的不是狼性，缺的是人性。百度的欺诈医疗推广伤天害理，道德伦丧啊。今年8月时，哥就被百度的欺诈医疗推广骗到了广州海军医院。仅就3B大战而言，哥支持360.

阿里：
马云成功回购雅虎持有的股票。阿里巴巴还是马云的阿里巴巴。淘宝商城改名天猫。电商大战如火如茶。。。。。

腾讯：
腾讯股票继续大涨。腾讯录用了哥是一大利好啊！资本市场因此非常兴奋吧。微信成功挤占了新浪微博用户的时间，并稳固了腾讯在IM市场的垄断地位。纯移动设计的微信在开放平台，o2o上给予投资者极大的想象空间。

马雅人不靠谱。2013 年大预测：
作为一个技术蝼蚁，水平有限，手痒手贱，预测一下2013年哈….

360搜索市场份额突破15%。3B大战升级。。。
小米神话破灭。。。。
360运营的Line即时通讯软件慢慢做大。因语音聊天功能触及运营商的高压红线，运营商和互联网公司的矛盾继续扩大。微信顺势也上线即时语音聊天，现在仅仅是语音对讲。
以前一直闷声发大财的9158因涉嫌情色被整改。
楼市回暖，全国平均涨幅10%

用Briss批量切除pdf文件的白边

Sun, 08 Jul 2012 04:36:34 +0000

这段时间准备论文，要看好多电子资料。比如中国知网下载的N多论文还有N多RFC的pdf。已经忍无可忍成天对住台电脑看资料，于是入手了一部kindle4。这下问题又来了，pdf(Portable Document Format)是专门为打印设计的，在页面的四个方向都预留了白边。对于kindle4本来就不大的屏幕来说，pdf显示在kindle4的屏幕上，字小的同乌蝇一样，比用电脑看还要费眼。于是想到去掉白边，在网络上搜索了一下，发现了好几种软件，最后哥选了briss，真的非常的酷喔~~可以把白边删除得干干净净。

不过问题又来了，我有好多pdf文件呀！但是briss的操作界面只支持一次处理一个文件。看Briss的帮助文件的时候发现Briss支持用控制台操作~~如下：

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

Command line usage(使用命令行)

If you prefer command line and trust the basic automatic detection algorithm use it this way (can be batched!):

如果你喜欢用命令行并信任白边自动推测算法，可以用以下命令操作（支持批处理）。

java -jar briss-0.0.13.jar -s [SOURCEFILE] [-d [DESTINATIONFILE]]

Example:

java -jar briss-0.0.13.jar -s dogeatdog.pdf -d dogcrop.pdf
java -jar briss-0.0.13.jar -s dogeatdog.pdf

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

到此，就非常好办了。我的电脑装了UNIX工具链在windows平台下的移植版:cygwin，于是我只用写一行unix命令就把我的一个目录夹下面所有的pdf文件都切边了。命令如下：

zausiu@enigma /cygdrive/e/kindle4/ipv6_en // 当前目录 e://kindle4/ipv6_en 下面存放了所有待切白边的pdf文件.

$ ls *.pdf | xargs -I'{}' -n1 java -jar d:/Program\ Files\ $x86$/briss-0.0.13/briss-0.0.13.jar -s '{}' // 用来把该目录下面所有.pdf文件去白边的命令。

我的pdf文件很多，随便贴出一点命令的输出。

Since no destination was provided destination will be set to : E:\kindle4\ipv6_en\draft-itojun-ipv6-transition-abuse-01_cropped.pdf

Clustering PDF: draft-itojun-ipv6-transition-abuse-01.pdf

Created 2 clusters.

Starting to render clusters…..finished!

Calculating crop rectangles.

Starting to crop files.

Cropping succesful. Cropped to:E:\kindle4\ipv6_en\draft-itojun-ipv6-transition-a=buse-01_cropped.pdf

Since no destination was provided destination will be set to : E:\kindle4\ipv6_en\layer2_attacks_and_mitigation_t_cropped.pdf

Clustering PDF: layer2_attacks_and_mitigation_t.pdf

Created 2 clusters.

Starting to render clusters……….finished!

Calculating crop rectangles.

Starting to crop files.

Cropping succesful. Cropped to:E:\kindle4\ipv6_en\layer2_attacks_and_mitigation_t_cropped.pdf

大概的意思是，我的命令没有提供切白边后新pdf文件的文件名，于是自动取了一个名字。然后程序分析pdf文件，开始切边，最后切边成功。

由于我写的命令是用了Unix Shell的语法，所以如果你的机器没有装cygwin是运行不了这个命令的。可以把它用windows批处理的语法改写，但是哥不会windows批处理的语法哈~~~

Linux内核Makefiles教程(二)

Sat, 07 Jul 2012 13:52:55 +0000

接第一篇

**3.3.**可加载模块目标 obj-m (Loadable module goals – obj-m)

obj-m指定将被构建为可加载内核模块的对象文件(object file)。

一个模块可以从一个源文件构建或者从多个源文件构建。如果模块仅仅从一个源文件构建，kbuild makefile仅仅把对象文件加到obj-m。如下：

#drivers/isdn/i4l/Makefile

obj-$(CONFIG_ISDN_PPP_BSDCOMP) += isdn_bsdcomp.o

_在这个例子中，__$(CONFIG_ISDN_PPP_BSDCOMP)_被求值为__m.

If a kernel module is built from several source files, you specify that you want to build a module in the same way as above.

如果一个内核模块需要从多个源文件构建，你也是按照刚才提到的那一行指定。不过，除此之外，还要额外地指定，你的内核模块需要哪些对象文件。所以还需要设置<模块名>-objs变量。如下：

#drivers/isdn/i4l/Makefile

obj-$(CONFIG_ISDN) += isdn.o

isdn-objs := isdn_net_lib.o isdn_v110.o isdn_common.o

在这个例子中，模块名是 isdn 。Kbuild将编译isdn-objs列出的所有对象文件，然后运行$(LD) –r把这些对象文件链接成一个文件isdn.o。

Kbuild用-objs后缀或者-y后缀识别构成复合对象文件(composite objects)的对象文件。这样，Makefile就可以使用CONFIG_* 符号来确定一个对象文件是不是一个复合对象文件的一部分。如下：

#fs/ext2/Makefile

obj-$(CONFIG_EXT2_FS) += ext2.o

ext2-y := balloc.o bitmap.o

ext2-$(CONFIG_EXT2_FS_XATTR) += xattr.o

Linux内核Makefiles教程(一)

Fri, 06 Jul 2012 08:17:50 +0000

Linux内核Makefiles

本教程描述了了Linux内核的Makefile是如何工作的。

1. 概述

Linux内核的Makefile包括五个部分。

<td style="width:373px;">
  <p>
    最上层Makefile
  </p>
</td>

<td style="width:373px;">
  <p>
    内核配置文件。
  </p>
</td>

<td style="width:373px;">
  <p>
    CPU架构相关Makefile
  </p>
</td>

<td style="width:373px;">
  <p>
    对于所有Kbuild&nbsp;Makefile的公共方法。.
  </p>
</td>

<td style="width:373px;">
  <p>
    有将近500个kbuild&nbsp;Makefiles。
  </p>
</td>

Makefile

.config

arch/$(ARCH)/Makefile

scripts/Makefile.*

kbuild Makefiles

最上层Makefile读取.config文件。.config文件是由内核配置过程生成的。

最上级的Makefile负责生成linux的内核映象文件vmlinux和其它所有的模块。最上级Makefile递归地进入内核代码树的各级子目录分别执行子目录下的Makefile。究竟要进入哪些子目录是由内核配置阶段决定的，即配置在.cncfig文件中。最上级Makefile提定了一个路径为arch/$(ARCH)/Makefile的子目录Makefile。这个Makefile中定义了与处理器架构紧密相关的信息。

每一个子目录下面都有一个kbuild Makefile，这里都定义了一些makefile命令和变量可以被更下级的Makefile继承。Kbuild Makefile使用来自.config配置的信息生成各种文件列表用来构建内建的或者模块化的目标文件。Scripts/Makefile.*包括了很多被其它Makefile使用定义和规则。

2. 谁使用内核Makefile

内核Makefile的使用者可以大致分为四种。

用户(Userse)

这类使用者仅仅敲入一些命令，如“make menuconfig”或者“make”。他们很少会阅读甚修改内核Makefile和源代码文件。

一般开发者（Normal Developers）

一般开发者一般编写一些设备驱动程序，文件系统，网络协议。他们需要维护他们编写的代码涉及的子系统的kbuild Makefiles。为了工作地更有效率，他们甚至还需要对整个内核的Makefile有全局的把握，包括对kbuild的公共接口的详尽了解。

处理器架构开发者(Arch Developers)

这部分开发者关心与某个处理器架构紧密相关的代码部分，比如PC上最广泛使用的x86，以及IA64，还有ARM,Sparc,PowerPC,Alpha,s390,MIPS。Linux支持几百种处理器架构。从内核2.6.24开始，i386和x86_64合并为x86。

KBuild的开发者(KBuild Developers)

KBuild的开发者就是维护内核构建系统的开发者，他们需要知道内核Makefile的各个方面。

——

本篇教程主要面向第二类开发者和第三类开发者。即一般开发者和处理器体系架构开发者。

3. kbuild文件

大多数内核Makefile文件是kbuild Makefile文件，它们使用不同于一般make文件的kbuild语法。下面会介绍kbuild makefile的语法。Kbuild文件一般被命名为Mafile，但是也可以使用Kbuild名字。如果已经存在一个Makefile文件了，那么就只好用Kbuild名字了。

中山大学软件工程专业Java语言课作业

Wed, 04 Jul 2012 02:52:24 +0000

这是11年中山大学软件工程硕士研究生java必修课的大作业，授课老师是温武少~ 讨厌写java代码。代码写得不好~不过，需要的童鞋可以拿过去改改。下载源代码！！！

下面是作业要求：

面向对象程序设计课程项目

基于JAVA银行管理系统设计(Case 2,3,4)

注意：如果发现全部或者部分copy程序，双方都将会被部分或者全部扣分。本课程是必修课，70分是通过线。

系统将依据3-tier架构设计银行管理系统。要求所有的项目用JAVA语言编程。设计的系统将是简化的银行管理系统。

项目二：银行管理系统Business Logic 设计（中程检查：10月31日（40%）;上交11月7日（60%），当堂运行+ftp上交）

所有的用户输入都是由命令行输入。项目必须提供设计文档、测试和运行报告。在线提交程序源程序。

1．银行用户分类: 普通个人用户，个人贵宾用户(VIP)，企业用户

对所有的用户必须支持以下功能：开户、存款、取款、查询、转账、改密码、销户等七项工作。所有对账户的操作都要产生日志。所有的数据都要永久化（存到硬盘）。系统重新启动时要能恢复数据。

（1）开户：调研银行管理系统需要存储的账户信息。

开户时需要身份证号码，决定开的账户类型，存款的初始金额。银行生成用户的帐号，用户输入初始密码。系统给出开户的时间日志。

（2）存款：

存款时需要给银行提供自己的账号，密码以及要存款的金额；银行系统反馈用户帐户的余额以及存款的日志。

（3）取款：

取款时需要给银行提供自己的账号、密码以及要取的金额；系统判断是否有足够余额以供取款。取款后给出用户帐户的余额，产生取款日志。

（4）查询：

查询时用户需要给银行提供自己的身份证、账号和密码；银行方面给出用户帐户的余额以及查询的日志。用户还可以查询一段时间所有的操作（流水）。

（5）转帐：（对不同用户转账有限制，请看账户类型说明）

用户转帐时需要判断是否能够满足转账条件。如满足，需要给银行提供转出帐户的账号、身份证号码、密码和用户名称及转入帐户的帐号和用户名称，用户也需要提供转账金额。系统方面将产生转账日志、转出用户帐户的余额等信息。

（6）改密码：

用户到银行改密码时需要给银行提供身份证、帐号、以及密码，并且输入新的密码。系统方面将产生相关日志。

（7）销户：

用户到银行销户时需要给银行提供身份证、帐号以及密码，并且把帐户的余额全部取出。系统方面将产生相关日志。

不同类型用户的特别限制和权限：

（1）所有的用户可开两种账户—活期和定期。用户的活期和定期账号之间可以转账。

（2）普通用户不能产生透支。

（3） VIP用户的初始存款额（包括活期和定期）要求大于100万，每月平均日余额要求不低于10万。如果连续2个月月平均日余额要低于10万，将收取每月1000元的管理费。VIP用户将能够透支最多 10万元。但要求透支的款项在规定的时间（30天）内归还。如不归还，账户将被冻结。

（4）转账只能在个人用户之间进行，或在企业用户之间进行。

（5）普通用户只能接收转账转入，不能转钱到别人的账户。但普通用户可以在他自己的账号内转账。VIP和企业用户容许转入、转出。

（6）企业用户容许多个账号操作人。我们指定其中的一到两个人作为账户超级用户，可以要求增加账户操作人。不同账户操作人必须使用不同密码。

（7）企业用户不容许透支。要求账面存款余额总数（包括所有的账户）不小于1万元。

2．银行雇员分类: 前台操作员，银行经理，银行业务总管、系统管理员。他们各自的职责:

系统必须能存储所有的雇员信息（自己调研）。银行经理管理一个或多个前台操作员，同时他可以做所有的前台操作员操作。银行业务总管管理一个或多个银行经理，他可以做所有的银行前台操作员及银行经理的工作。

银行雇员操作：

（1）前台操作员：对账户所有的操作。雇员本身所作的操作的日报，月报，季度报和年报（包括数据和日志）。前台操作员向一个银行经理报告。

（2）银行经理：作为前台操作员的所有操作，部门操作的日报，月报，季度报和年报（包括数据和日志，及每个成员的报告）。银行经理必须较容易查到他部门人员总数及具体情况。银行经理向银行业务总管报告。

（3）银行业务总管（包括个人账户和企业账户两类）：作为前台操作员和部门经理的所有操作，整个银行相关业务操作的日报，月报，季度报和年报（包括数据和日志，及每个成员的报告，每个部门的报告）。银行业务总管应较容易查到他所管人员总数及具体情况。

（4）系统管理员：雇员管理。产生整个银行的总报表和总日志（日报，月报，季度报和年报）。

3．（加分 20%）银行系统网络接口

提供外面银行在线操作要求（必须提供通过网络提供各种操作需要的信息）。在线操作必须产生专用的日志。

项目三：银行管理系统后台数据库及接口设计（上交11月21日，当堂运行+ftp上交）

数据存储采用数据库（建议用MYSQL.把business logic 层修改以支持数据库。

项目四：银行管理系统UI设计（开放设计，上交11月28日，当堂运行+ftp上交）

所用的用户输入和输出采用GUI。

说明：项目总成绩计算：项目1： 20%

项目2： 50%

项目3： 15%

项目4： 15%

更多说明：

1.运行报告主要是指：系统所实现的所有功能的运行截图；

2.所谓“冻结”的意思是：只能查询余额，不能进行存款、取款的操作；不要求实现“解冻”，也就是这个账号一旦被冻结，这辈子就“冻”死了；

三分钟Qt Quick入门

Tue, 03 Jul 2012 07:32:35 +0000

Qt Quick是一种设计用户界面的新方法。

在介绍Qt Quick之前，让我们先看一下现念的用户界面UI是什么样的。在桌面操作系统下，标准的按钮，文本框，窗体仍然能满足要求。但是这些千篇一律的灰色单调的控件渐渐让用户感到厌倦了。用户们更想看到平滑观感的，光泽的，动态的的用户界面。Qt Quick就是为了实现这些的目标。

Qt Quick包括两个部分。第一部分是QtDeclarative模块。这个模块负责把Qt Quick集成到Qt应用程序中。第二部分是一种界面描述语言：QML。使用QtDeclarative使得开发者能够在C++和QML之间共享数据对象，也可以把C++类插入到QML之中，等等。QML是个全新的语言，专门为设计用户界面设计，在其它的开发中也有用武之地。

迫不及待了吧。让我们看一个简单的例子：

import Qt 4.6

Rectangle {
width: 200
height: 200

Text {
text: “hello! ykyi.net”
font.pointSize: 10
font.bold: true

anchors.centerIn: parent
}
}

读完这断代码，再尝试在Qt Creator中运行它。不用我多费口舌，你就恍然大悟了。每一个以大写字母开头的单词定义了一个新的对象。最外面的矩形则是主窗体，可以给它设置属性。比如anchors属性把Text限定在窗体的中央。这样，即使窗体放大了，文本仍然显示在窗体正中央。

前文，我有说过平滑观感的，光泽的，动态的的用户界面。那么Qt Quick怎么做到呢？简单！看看下面的代码，编辑Text的属性，设置rotation:NumberAnimation。不可思议的事情就发生了！

rotation: NumberAnimation {
to: 360;
duration: 1500;
running: true;
repeat: true;
}

现在，指定的文本疯狂的转动起来。我们已经看到在Qt Quick中开发有物资的界面是多么简单。我们所展示的只是Qt Quick特效的凤毛一角，最终能创造出什么样的奇幻效果只受限于你的想象力。

Barebox介绍

Mon, 02 Jul 2012 12:39:14 +0000

从裸机上电开始启动计算机的过程听起来是相当复杂的。在PC的世界里，BIOS统治这个领域已经几十年了。不过，哲学上讲任何世界都是从出生，到繁荣，再后到死亡的过程。BIOS的寿命也即将迎来终结。BIOS的掘墓者即是EFI。对于MAC用户来说，EFI的使用已经有好长一段时间了。而在嵌入式Linux的世界里，u-boot则在长时间里扮演着老大哥的角色。

U-boot，或者来自DENX的das U-boot提供了非常丰富的功能。如：网络，脚本，支持FLASH(这里的flash是存储方面的flash，而不是adobe的那个flash)。一般的嵌入式系统工程序师需要的工具，都提供好了。

还是那句话，对于万事万物，都是生生死死的过程啊。u-boot的功能越来越强大。催生了新的事物的诞生。它的名字就是：Barebox。

Barebox最开始被称之为：u-boot-v2，它是一个像u-boot一样野心勃勃的bootloader。不过Barebox更有Linux的味道一些。它的发展抛弃了u-boot而越来越像Linux。它有文件系统，有基本的shell，甚至还有与Linux近似的驱动模块。

Barebox的另一个创新即是，bootloader可以被构建成一个用户空间的应用程序。这样的好处是显而易近的，你可以更方便的开方和调试Barebox。

说了这么多，看看Barebox是个什么样子呢？

uboot:/

uboot:/ ls
. .. dev env

和Linux一样，dev目录夹下面放了系统的设备文件。比如，mem设备文件描述了计算机的内存。

再回到u-boot，它有一个特殊的命令：md。md命令可以查看内存的内容。对于Barebox，提供了同样的工具。不过这个工具是以一种POSIX的方式实现的：打开/dev/mem设备，lseek移动文件指针，read读出文件内容。这样的实现方式不仅仅提升了代码结构，它还使得md命令可以不需修改就应用到其它设备上，比如flash存诸器。

如果你想测试一下Barebox到底如何。你可以有两种方法。

第一：你可以下载Barebox的沙盒功能即把它构建成一个Linux的用户空间的应用。来自Barebox官方的解释是：

Sandbox:
If you develop features for Barebox, you can use the ‘sandbox’ target which compiles Barebox as a POSIX application in the Linux userspace: it can be started like a normal command and even has network access (tun/tap). Files from the local filesytem can be used to simulate devices. 如果你要为Barebox开发功能，你可以使用’沙盒’。这种方式把Barebox构建成一个Linux的用户空间程序。它像一般的命令一样，而且还有网络功能。来自文件系统的文件可以被用来模拟设备。

第二：不说你也知道，把Barebox安装到真真正正的硬件上吧！对于我，我就尝试过在PC机的一块旧式的主板上安装Barebox。

最后，Barebox的官方网站是： http://barebox.org/

Linux如何设置IPv6地址

Sun, 01 Jul 2012 08:46:32 +0000

IPv6最终全面取待IPv6是不可逆的潮流。本文则讲一下在Linux下如何配置IPv6地址。当然本文假设你使用静态IP（不必是公共IPv6地址或公共IPv4地址，可以是私有IPv4地址）。本文不适用使用DHCP获取地址的情况。

首先，你要确保你使用的Linux的内核已经支持IPv6。当前比较新的Linux都已经内建IPv6了。

用root用户登录，运行：

# lsmod | grep ipv6

看看系统有没有已经加载了IPv6模块。如果没有，尝试用以下命令加载：

# /sbin/modprobe ipv6

第二，你需要有你的静态IP地址。

**IPv4地址如何转成IPv6地址呢？**如果你的IP是一个IPv4地址，那么可以换算得到IPv6的地址形式。比较简单的作法可以去到 http://grox.net/utils/ipv6.php。在左边的下拉列表中选择: IPv4 to 6to4 Address，在右边的编辑框中填上你的IPv4地址。点击: Calculate 则得到了你的IPv4地址的IPv6转化格式。

配置IPv6地址

一般的Linux发行版用 /etc/network/interfaces 文件配置网卡。如果没有这个文件，那么请注意 /etc/network 目录下其它文件或者目录。

假如要配置的Linux的静态IPv4地址是 192.168.1.10，这个IPv4地址转换成对应的IPv6地址则是 2002:c0a8:10a:: 。再提醒一下，上文提到过如何把IPv4地址转成IPv6地址。

网关的IPv4地址是 192.168.1.1，这个IPv4地址转成对应的IPv6的地址是:2002:c0a8:0101:: 。

那么 /etc/network/interfaces 文件应该配置成如下：

#IPV6 static configuration(我是注释)
iface eth0 inet6 static
pre-up modprobe ipv6
address 2002:c0a8:10a::
netmask 64
gateway 2002:c0a8:0101::

注意 “pre-up” 命令。这一行保证系统在启动的时候加载支持ipv6的模块。
最后重新启发动网络，如下：

# /etc/init.d/networking restart

你现在可以使用你的IPv6地址了。

测试IPv6地址：

检测路由：

# ip -6 route show

如果IPv6工作正常的话，应该会有如下的提示。

2002:c0a8:0100/64 dev eth0 proto kernel scope link src 2002:c0a8:10a

X86平台的中断和异常

Sat, 30 Jun 2012 04:42:06 +0000

英特尔的官方文档如下定义x86平台下的中断和异常：

中断：

可屏弊中断(Maskable Interrupts)

所有由I/O设备发出的IRQ(Interupt Requests)都是可屏弊中断。可屏弊中断可以有两个状态：屏弊和未屏弊。屏弊状态的中断会被中断控制硬件忽略。

不可屏弊中断(Nonmaskable Interrupts)

只有一些关键的事件（如硬件失败）会发出不可屏弊中断。不可屏弊中断总是可以被CPU识别到。

异常：

处理器可侦测异常(Processor-detected Exceptions)

CPU执行指令时侦测到不正常的状态(anomalous condition)时产生这个异常。这种异常又根据存在内核栈上的EIP寄存器的值被划分为三组。

错误(Faults)

发生错误时，一般情况下可以被纠正。纠正以后，程序继续运行，不会损失连续性。保存下的EIP寄存器的值就是产生这个错误的指令，当异常处理句柄（exception handler）结束后，程序从这条指令继续运行。

陷入(Traps)

当被中止的指令无需重新执行时就产生陷入，这点与错误(Faults)不同。陷入主要被用来实现调试器。

中止(Aborts)

严重出错。控制硬件出现故障，此时不可能把造成异常的指令精确地址存入EIP寄存器。Aborts被用来报告严重的出错，比如硬件出错或者无效的，不一致的系统表结构。由控制硬件单元发出的中断信号被用来把控制权转交给中止异常句柄(Abort Exception Handler)。句柄通常只有强制结束造成Abort的程序。

可编程异常(Programmed Exceptions)

这是由程序员发出的。程序员可以用int 或者int 3指令发出可编程异常。Into(检查溢出)bound(检查数组越界)指令也可以用来发出可编程异常。可编程异常常常被称之为软中断(software interrupts)。这种异常通常用来实现系统调用，还被用来在调试器中报告事件。(into和bound指令在IA64体系中已经被废弃了，见另一篇博文：C语言和它的安全性)

中山大学离散数学考试试题

Fri, 29 Jun 2012 05:39:07 +0000

《离散数学》期末试题(A卷)

ykyi.net

(考试形式:闭卷考试时间:2小时)

《中山大学授予学士学位工作细则》第六条

考试作弊不授予学士学位

方向：姓名：学号：

出卷：复核：

1. (10 points) A, B and C are sets, prove or disprove the following statements.

(1). if A – B = A – C, then B = C

(2). if A ´ B = A ´ C, A ¹ Æ, then B = C

2. (10 points) Write each of the following statements in terms of propositional variables, predicates, quantifiers and logical connectives. You can choose any propositional variables and predicates freely.

(1). If I like the course or the teacher, I will attend the class. (statement and its negation)

(2). For all students of our school, someone studies hard and has good score, someone studies hard and does not have good score.

Note: The first question is expressed in propositional logic, the second is expressed in predicate logic.

3. (15 points) Let A={a,b,c,d,e}, a relation R on A is {(a,b), (b,b), (b,c), (b,d), (c,d), (d,d), (d,e), (e,d)}.

(1) Give the digraph and matrix of relation R;

(2) Compute R2, reflexive closure r(R) and symmetric closure s(R).

4. (15 points) Let SÎZ+ and A=S×S. Define the following relation R on A:

(a,b) R (a′,b′) if and only if ab′=a′b

(1) Show that R is an equivalent relation;

(2) Let S={1,2,3,4,5,6,7,8,9}, compute the equivalent class [(2,4)].

5. (10 points) Let function f(x, y)=( x+3y, 2x+y), (x, y)ÎR×R, prove that f is bijection.

6. (15 points) Let A={2, 4, 5, 6, 8, 10, 12, 20, 120}, R is the relation of divisibility on A.

(1) Draw the Hasse diagram of the poset ;

(2) Find all the minimal elements, the maximal elements, the least element and the greatest element of the poset if they exist;

(3) Let B = {2, 4, 6}, find the upper bound, the lower bound, the least upper bound and the greatest lower bound of B if they exist.

7. (15 points) Use the labeling algorithm (Ford-Fulkerson’s) to find a maximum flow for the following transport network in Fig. 1. Use of figures is required to show the variety of flows during the procedure.

什么是MediaWiki的Gadget(小部件)

Thu, 28 Jun 2012 02:52:41 +0000

译自MediaWiki的官网，URL： http://www.mediawiki.org/wiki/Extension:Gadgets

Gadget简介：

MediaWiki，为用户提供了一种方法，使用户方便使用其它用户基于Javascript或者CSS创建的小部件Gadget.

Gadget是由Javascript或者CSS代码片断组成的，被放置在MediaWiki名字空间里(对于MediaWiki的名字空间的概念请参看其它文章)。每一个Gadget都在MediaWiki:Gadgets-definition中占用一行，用来定义这个gadget。定义包括这个Gadget的名字，和描述以及组成这个Gadget的Javascript和CSS代码。

因为Gadget被放置在MediaWiki名字空间里，只有系统管理员可以编辑Gadget。这很容易理解：只有充分被信任的用户才可以编辑被其它更多用户使用的Javascript代码。Javascript代码是把双刃剑，如果被用来做坏事，会很容易被用来实现劫持账号或者监视用户的功能。

下载Gadget：

从https://gerrit.wikimedia.org/r/gitweb?p=mediawiki/extensions/Gadgets.git;a=tree 可以下载到Gadget，或者也可以用git工具clone一份gadget，如下：

git clone https://gerrit.wikimedia.org/r/p/mediawiki/extensions/Gadgets.git

如何安装：

把Gadget目录复制到你安装MediaWiki的扩展目录(Extensions Folder)。然后在localSetting.php文件中，接近文件末尾的地方加上一行：

require_once( "$IP/extensions/Gadgets/Gadgets.php" );

使用Gadget:

可以使用的Gadget定义在MediaWiki:Gadgets-definion。只要有一个有效的Gadget在MediaWiki:Gadgets-define被定义，就能在每个用户的Special:Preference的Gadgets节选择是否启用这个Gadget(小部件)。在Special:Gadgets也能浏览Gadgets的列表，并有链接指向各自的系统消息(System Message)，以方便编辑。

定义Gadget的格式：

在MediaWiki:Gadgets-definition中的每个Gadget的定义都以一个或者多个"*"开始，必须符合下面的格式定义。

* Gadget的名字 [ 选项(可以忽略) ] | 页名字

(* gadget_name [options (can be omitted)] | page names)

第一个域，Gadget的名字指的是gadget的内部名字。这隐含了一个系统消息的引用(System Message)。此例中，如果你定义了内部名为 my_gadget_name 这样一个gadget，则在MediaWiki:Gadget-my_gadget_name有一个使用wiki语法的关于这个gadget的简短描述。

注意，gadget的内部命令规则：必须以字母起头，后面可以接26个字母的大小写或者数字，以及连字符“-”，下划线“_”，冒号“:”，点号“.”。

选项的格式：

[option1 | option2 | … optionN]

空格将被忽略。每一个选项可以包括一个选项名，或者选项名还能被赋值，这些值以逗号隔开。如： option = value1, value2, value3

举一些Gadget定义的例子：

* mygadget|mygadget.js|mygadget.css

* mygadget[ResourceLoader]|mygadget.js|mygadget.css

* mygadget[rights=foo,bar]|mygadget.js|mygadget.css

* mygadget[ ResourceLoader | rights=foo, bar ] | mygadget.js | mygadget.css

选项的说明:

  <td style="width:150px;">
    <p>
      参数
    </p>
  </td>
  
  <td style="width:359px;">
    <p>
      描述
    </p>
  </td>
</tr>

<tr>
  <td style="width:68px;">
    <p>
      ResourceLoader
    </p>
  </td>
  
  <td style="width:150px;">
    <p>
      None
    </p>
  </td>
  
  <td style="width:359px;">
    <p>
      注明Gadget与ResourceLoader兼容。
    </p>
  </td>
</tr>

<tr>
  <td style="width:68px;">
    <p>
      dependencies
    </p>
  </td>
  
  <td style="width:150px;">
    <p>
      用逗号分隔开的ResourceLoader模块名
    </p>
  </td>
  
  <td style="width:359px;">
    <p>
      这里有<a href="http://www.mediawiki.org/wiki/ResourceLoader/Default_modules">默认依赖的模块列表</a>.如果当前的gadget没有与ResourceLoader兼容的资源，这个选项将失效。
    </p>
  </td>
</tr>

<tr>
  <td style="width:68px;">
    <p>
      rights
    </p>
  </td>
  
  <td style="width:150px;">
    <p>
      用逗号分隔开的权限名
    </p>
  </td>
  
  <td style="width:359px;">
    <p>
      权限名列表在这里&nbsp;<a href="http://www.mediawiki.org/wiki/Manual:User_rights#List_of_permissions">privileges</a>.
    </p>
  </td>
</tr>

<tr>
  <td style="width:68px;">
    <p>
      skins
    </p>
  </td>
  
  <td style="width:150px;">
    <p>
      用逗号分隔开的皮肤名
    </p>
  </td>
  
  <td style="width:359px;">
    <p>
      皮肤名列表在这里&nbsp;<a href="http://www.mediawiki.org/wiki/Manual:Skins">skins</a>.
    </p>
  </td>
</tr>

<tr>
  <td style="width:68px;">
    <p>
      default
    </p>
  </td>
  
  <td style="width:150px;">
    <p>
      无
    </p>
  </td>
  
  <td style="width:359px;">
    <p>
      注明对每个用户，包括匿名用名默认启用的gadget。不过注册用户仍然可以在它们的使用偏好设定中禁用gadget.
    </p>
  </td>
</tr>

选项名

你可以为你的gadget指定额外的依赖，如：

显卡信息检测利器，GPU Caps Viewer介绍

Tue, 26 Jun 2012 23:22:05 +0000

怎么知道我的显示是不是支持OpenCL？GPU Caps Viewer可以告诉你答案。

<div>
  <span style="font-size:14px;">GPU Caps Viewer是一款让监控你的显卡工作情况的好工具。</span>
</div>

<div>
  &nbsp;
</div>

<div>
  <span style="font-size:14px;">比如，如果你是一个骨灰级游戏玩家，或一个WEB开发者，需要一款图形显示卡方面的应用软件，那么GPU Caps Viewer是你的最佳选择。</span>
</div>

<div>
  &nbsp;
</div>

<div>
  <span style="font-size:14px;">GPU Caps Viewer的操作界面非常直观。你可以方便地查看你的GPU的各种信息，包括：光影核心(Shader Core),BIOS,设备ID号，次设备ID号，GPU的温度，当前和最大时钟，GPU的负载，显卡的驱动程序，OpenGL, OpenCL，CUDA，PhySX，并且支持多GPU。</span>
</div>

<div>
  &nbsp;
</div>

<div>
  <span style="font-size:14px;">你还可以启动一个OpenGL或者OpenCL的演示程序，查看OpenGL的版本号和它的扩展链表，CUDA设备的数目,核心数据 &#8212; 如名字，计算力，光影时钟，多处理器，变形和网格尺寸(warp and grid size)等等。</span>
</div>

<div>
  &nbsp;
</div>

<div>
  <span style="font-size:14px;">还可以查看更多的内容。你可以查看到显卡的OpenCL信息，如版本号，CL设备的数目，CL设备的类型，计算单元，时钟，驱动程序，全局和局部内存，2D和3D图象的尺寸，工作项目的尺寸(work item size)，常量缓冲区，最大采样器，扩展，工作组的尺寸，等等。</span>
</div>

<div>
  &nbsp;
</div>

<div>
  <span style="font-size:14px;">另外，还能查看到系统信息。如CPU的名字，CPU的型号，CPU的核心，使用了什么操作系统，内存的信息，显示模式等等。界面上有各种链接导向相应的网页以供查看更详细的信息。界面上的大部分信息可以被导出到txt或者xml文件。</span>
</div>

<div>
  &nbsp;
</div>

<div>
  <span style="font-size:14px;">需要注意的是，GPU Caps Viewer运行时使用非常多的系统资源，而且软件作者也没有提供一个帮助文档。面对满界面的专业术语，GPU Caps Viewer软件的定位应该是高级用户。该软件可以在各大下载论坛下载到。</span>
</div>

<div>
  &nbsp;
</div>

<div>
  <span style="font-size:14px;">本文一开始的问题&ldquo;<strong>如何知道显卡是否支持OpenCL</strong>&rdquo;则可以在OpenCL标签项中得到答案。如果显示卡不支持OpenCL,则不会有关于这块显卡OpenCL方面的信息，当然也不能运行OpenCL的演示程序(Demo)。</span>
</div>

<div>
  &nbsp;
</div>

<div>
  <span style="font-size:14px;">copyright ykyi.net</span>
</div>

<p>
  &nbsp;
</p></p>

ThreadX简介

Tue, 26 Jun 2012 06:49:21 +0000

ThreadX是由在美国加利费尼亚州，圣地亚戈的Express Logic有限责任公司开发并注册商标。它是一个实时操作系统，类似于VxWorks, Nucleus RTOS, OSE, QNX, LynxOS这些实时操作系统。ThreadX的作者是William Lamie，它是Express Logic有限公司的董事长兼CEO。

为什么ThreadX取这样一个名字呢？ThreadX的这个名字缘于线程(Thread)是被操作系统调度的单位，字母X就表示切换线程。ThreadX可以被看成是SystemC的QThreads的抢先式实现。

与大多数实时操作系统一样，ThreadX的内核是多任务抢先式内核，支持快速响应中断，内存管理，线程通讯，互斥，事件，线程同步等特性。

ThreadX的一些独有的特性有：优先级继承，抢先阀值，高效定时器，pico内核设计，事件链，高速软定时器，以及精致的内核尺寸。ThreadX是开源发布的，并且使用ThreadX不需要任何授权费用。

ThreadX常常被使用在实时嵌入式操作系统中，特别是嵌入程度很大的嵌入式系统(Deeply embedded system)。ThreadX的开发通常都在运行Linux或者windows操作系统的机器上用交叉编译环境开发。交叉编译工具可以生成在目标平台上运行的二进制代码。已经有很多可以用来开发ThreadX的开发工具，比如：Wind River Workbench, ARM RealView, Green Hills Software's MULTI, Metrowerks CodeWarrior, IAR C-SPY,Lauterbach TRACE32, 和visionCLICK

最近，Hewlett-Packard已经被授权可以使用ThreadX开发喷墨打印机，激光打印机，一体化设备。早些时候，开发多功能激光打印机使用lynxOS操作系统，目前仍然有很多打印机设备设用lynOS。如今，ThreadX已经被广泛使用在很多消费电子设备，医疗设备，datanetworking applications，还有SoC的开发。

红帽的云计算机解决方案

Mon, 25 Jun 2012 03:42:48 +0000

Red Hat Cloud

未来的云计算一定是开放的

对于一个公司负责IT的领导层来讲，选择一个正确的云计算机架构是一件极为重要的战略决策。这将影响到你的企业在这个十年的竞争力和灵活性。所以，务必谨慎选择。

如果这个事做正确了，云计算将帮助你从过去的简单控制资源的配额过渡到真正的革命性变化。但是，只有一个开放的云计算解决方案可以做到。

只有红帽提供了一个真正的开放云计算解决方案

红帽作为开源软件业的引领者，为你提供了构建一个开放去计算解决方案所需要的一切。拥抱全面开放的云计算吧，你的企业才真正认识到什么是云。

1. 让数据在云之间自由迁移。

2. 全面利用已有的IT投资和基础设施。

3. 跨越物理服务器，多种虚拟化平台，以及运行着各种各样不同技术栈的公共云。

4. 使企业平滑过渡到云时代，在每一个步骤都能获得持续的收益。

5. 你对选用什么技术有真正的话语权。

更多的选择：

红帽拥用最有活力的生态系统，一大批认证的云计算提供商，硬件提供商，Paas(Platform-as-a-service)中间件的提供商。毫无疑问，红帽是能够给你提供最多最自由选择的云计算平台。

红帽的开放云让IT公司或者企业的IT部门在经济上容易承受，并使用开放的应用程序编程接口(API)，充许用户自由的迁移到其它的云，使你能够控制和领导你的IT愿景(Let you control and lead your IT vision).

We can strengthen your open cloud by drawing on more than a decade of experience and technology powering mission-critical infrastructures and applications for the world's most demanding organizations—including top public clouds. All while providing the Red Hat service levels and control our customers expect.

flexcoin全世界第一家Bitcoin銀行

Sun, 24 Jun 2012 07:39:58 +0000

Bitcoin是互聯網上一種虛擬貨幣，欲知更多自己搜索下，已經有很多文章介紹了。

Flexcoin.com是網路上第一家基於於Bitcoin的銀行。Flexcoin使你可以在全世界所以可以連接到互聯網的地方使用Bitcoin。

如果你把Bitcoin存到flexcoin.com，你就有了一個賬戶可以轉出以及收款。另外，如果在每月月底你的賬戶中有正數值的余額的話，flexcoin還會給你一部分利息。

換言之，就如同真實世界中的銀行一樣，只是這裏使用的是Bitcoin，而不是任何政府發行的貨幣。

Flexcon是整個Bitcoin體系中一個非常重要的部分。我們的技術使我們可以為用戶做到通過用戶名快速轉賬到一個用戶名下，而不是一串奇怪的數字標志的用戶名。如下：

Before Flexcoin: 1555hjPG7pRwTHVMfukPvjXexQMHFE3qu6

After Flexcoin: coffeeshop

Flexcoin解決了Bitcoin貨幣體系中一個很大的問題。

Flexcoin出現前，當別人給你發來Bitcoin，你只有從你初次接收它的設備上操作它。你不能夠，至少不能輕易地通過你的手持設備或者其他什麼設備使用它。一般地講，只有在你初化接收和發送Bitcoin的機器上才能操作Bitcoin。通過使用Flexcoin，你甚至可以把Bitcoin發送到一個電郵地址。Flexcoin的設計使即使不怎麼懂技術的用戶也能夠使用。

Flexcoin做的工作看起來很簡單，他提供了一個集中的處理你所有Bitcoin財產的地方。Flexcoin就是全世界第一家Bitcoin銀行。你可以通過任何可以使用Web的設備用一個賬號來管理所以屬於你的Bitcoin。

這樣就使你可以在各種場合各個時間段也能夠發送和接收Bitcoin。只要你有一臺可以用Web方式登錄到Flexcon.com的設備。

Flexcoin也是整個Bitcoin界的安全引領者。比如，Flexcoin是第一個實現了在電郵件絕不放置URL的機構。從Flexcoin發出的電郵絕對不會有鏈接或者圖象。如果你收到一封違反剛才聲明的電郵，那一定是欺詐郵件。

Bitcoin的官方網站是 www.bitcoin.com

MediaWiki入门教程

Sat, 23 Jun 2012 13:27:25 +0000

MediaWiki是这个世界上使用人数最多的百科建站系统。全球最著名的Wikipedia.com就是用MediaWiki建立的。另外，MediaWiki是在GPL协议下免费开源工程，这意味着你可以免费使用它。下面将介绍如何使用MediaWiki.

如何安装MediaWiki？

从官网下载到MediaWiki的安装包，解压到服务器的根目录下面。然后用你的域名访问网站，就会提示你一步一步安装了。注意最后一个步骤会生成一个LocalSettings.php文件，你需要把这个文件上传到网站的根目录。如果没有把生成的LocalSettings.php放到根目录，下次输入域名访问网站会提示找不到LocalSettings.php。其实整个安装都超级简单！

怎么使MediaWiki只能够被私人使用？

在安装阶段有这个选项配置MediaWiki会被如何使用。如果错过了，可以删除根目录下的LocalSettings.php，再输入域名访问网站重新生成LocalSetting.php。这样有点麻烦，也可以直接编辑LocalSettings。比如:

# 禁止未登录用户编辑内容.

$wgGroupPermissions[‘*’][‘edit’] = false;

# 禁止用户注册，除非系统管理员创建用户。

$wgGroupPermissions[‘*’][‘createaccount’] = false;

怎么创建一个页面？

在这个例子中，我们会教你创建一个页面。页面的内容就是'如何创建一个页面'。

在网站的右上角上点击：登录。然后用你的管理员账号登录。

在MediaWiki中创建一个页面的方法有点特殊。首先，你在搜索框中输入你将要编辑的词条名字，然后点击搜索。如果词条不存在的话，就会显示一个页面告诉你没有这个词条。在这个页面上会有一个选项提示你创建这个词条。点击“创建词条”。

输入以下内容：

== Create a page ==

* 把词条输入搜索框，然后搜索。

* 搜索结果显示没有匹配到任何页面，这时有一个选项让你创建一个页面。

* MediaWiki标志语言(MediaKiki Markup Language也常被称为:wikitext)可以在 http://www.mediawiki.org/wiki/Markup_spec 找到。

* 各种编辑页面的例子可以在 http://meta.wikimedia.org/wiki/Help:Editing and http://meta.wikimedia.org/wiki/Help:Wikitext_examples 找到。

点击"预览"按钮，可以看到页面的预览效果。点击"保存页面"，则这个页面被编辑完成了。

怎么改名一个页面？

有时候你想要把一个页面改名。MediaWiki处理改名的逻辑实际上是把这个页面使用新的名字移动到一个新的位置，MediaWiki会记住旧的名字，还会建立一个到新页面的引用。

在页面的上部找到"移动"标签页，点击!

填好新的页面名字，点击"移动页面"按钮。

系统会让你确认一次，然后改名就完成了。

怎么改变MediaWiki的Logo呢？

常常有人问如何把网站左上方的网站Logo换掉。

首先你创建一个宽135象素，长135-150象素的logo图象文件。把logo上传到服务器某个位置。默认是放在/skins/common/images/wiki.png。

编辑LocalSetting.php文件，修改 $wgLogo变量。

刷新页面，现在你可以看到新的Logo了。

怎么在页面中建立内部链接(Internal Links)？

不像标准的HTML语法，在编辑MediaWiki的页面时建立指向内部页面的链接是非常容易的。比如你要建立一个到词条名为“我爱香港”的内部链接，则在编辑页面时在词条名前加井号。

如: #我爱香港

MediaWiki的内部链接的颜色有两种，一种是红色，一种是绿色。当内部链接的颜色是红色时，表示还没有收录这个词条，如果你点击的话，会提示你建立新词条。如果是绿色，则相反。

如何改变MediaWiki的导航菜单？

比如我想要把我的wiki站点上所有的category都列在导航条上，那我就需要修改导航条。

在搜索框中输入: Mediawiki:Sidebar。搜索结果会给出导航条的页面。

选择“编辑”。

增加一行以**起头，|符号前面的字符表示导航项将要显示的名字，|后表示页面的名字。

最后选择保存页面，完成！

It’s a mistake to include Xen in a Linux distro

Fri, 22 Jun 2012 13:21:30 +0000

As the title show, it’s a mistake to include Xen in a linux distro. Why?

Somebody would argue that Xen is a very useful technology. Xen does the virtualization work very well and many projects are using Xen which prove Xen is so great.

I’m not mean Xen is not good. However, just because Xen is a hypervisor that is based on another microkernel that is not Linux kernel itself. Linux distros that ship Xen today actually are running an entirely different Operating System kernel that most users even don’t notice that. Xen should be a separate, purpose-built kernel, so it should never be a part of the Linux kernel. Isn’t it strange that you think you are running a linux OS, but this ’linux’ has a kernel that is not linux, which is another kernel. You take away the Linux kernel, how could you say the OS is Linux.

什麼是敏感指令

Thu, 21 Jun 2012 08:20:55 +0000

1974年，Popek和Goldberg在美國电脑協會的通訊期刊上發表了一篇論文"虛擬化第三代架構的一般性要求"(Formal Requirements for Virtualizable Third Generation Architectures)。在這篇文章中，提出了敏感指令的概念。

敏感指令(Sensitive Instructions)的定義： 敏感指令是這樣一組指令，這些指令的行為取決於指令執行時處理器的工作模式，以及指令在記憶體中的位置。

——-

對敏感指令的處理是虛擬化技術的一個關鍵點。在用戶態執行的敏感指令如果總會造成陷入(always generates a trap)，這樣的敏感指令也屬於特權指令。在不使用Wmware提出的動態二進制翻譯機制的情況下，除非所有的敏感指令都是特權指令，虛擬機管理程式才能保證正確運行。換言之，如果某種處理器架構的所有的敏感指令都是特權指令的一個子集，我們就可以說這種處理器架構是可虛擬化的。在這種情況下，我們就可以肜經典的“陷入後模擬“(trap-and-emulate)的方法實現虛擬化。按照這個定義，在嵌入式工業中最常見的ARM架構則不是可虛擬化的，因為ARM的敏感指令有些是特權指令，有些則不是。

原文 from the paper “KVM for ARM” by Christoffer Dall and Jason Nieh, Columbia University：Popek and Goldberg define sensitive instructions as the group of instructions where the effect of their execution depends on the mode of the processor or the location of the instruction in physical memory. A sensitive instruction is also privileged if it always generates a trap, when executed in user mode. The VMM can only guarantee correct execution without the use of dynamic translation if all sensitive instructions are also privileged. In other words, an architecture is virtualizable if and only if the set of sensitive instrucctions is a subset of the seet of privileged instructions. If that is the case, the VMM can be implemented using a classic trap-and-emulate solution. Unfortunately, ARM is not virtualizable as the architecture defines both sensitive privileged instructions and sensitive non-privileged instructions.

traceroute failed.Specify protocal traceroute used manually to fix it.

Wed, 20 Jun 2012 14:37:16 +0000

Today, I ran the traceroute program on a machine running FreeBSD. It failed once and again.

Traceroute complained:

traceroute: sendto: Permission denied.

So I tried to ping. Ping failed, too. I then checked out the configuration of the firewall, which actually denied the pass through of ICMP packet. So I set it to allow ICMP pacakges to pass through the firewall. Ping worked as I expected. But traceroute still failed.

如何正确地提交内核补丁包

Wed, 20 Jun 2012 11:39:56 +0000

原文：https://lwn.net/Articles/500443/

翻译：ykyi.net

Greg Kroah-Hartman(又Greg KH)在执行一个了不起的作务：减少内核开发者，尤其是维护者的暴躁情绪。他在日本横滨举行的全球Linux大会上的讲演呼吁公众理解内核维护者的工作，内核贡献者的什么样的行为会导致内核维护者变得暴戾。但是，如果内核贡献者们能够遵守一些约束，他代表他自己做了许多承诺。

Greg Kroah Hartman把Linux内核称之为"有史以来最宏大的软件开发项目"，而且它的开发速度也是“亘古未有”。从3.0到3.4，有373个公司的2833位开发者参于了Linux内核的开发。这一年，(2011年的5月到，2012年的5月)，Linux内核在每个小时会有5.79处变动。而且这个开发速度仍然要加速，如果你看看3.4的开发过程，每小时共有7.21处变动。这里所说的变动仅仅指能够被合并到主干的补丁包，而那些被拒绝的补丁包没有被统计进来。

补丁包修改了哪些文件，内核开发者就把补丁包发给负责这些文件的维护者。所以的内核维护者，现在大概有700人。他们把改变应用到130个子系统的维护者那里。再从子系统的维护者到Linus的Linux内核代码分支。最后并必Linux内核的主干。如果提交的补丁包一路通过的话。

因此，来看看为什么一些补丁包不会被接受呢？Greg Kroah Hartman以刚过去的两个星期收到的补丁包为例，这两个星期刚好处于3.5版本的Merge Window时间。Merge Window是一个他确不应该接收到许多补丁包的时间段。他应该在Merge Window开始前收到所以有可能会在Merge Window其间被发往Linux Torvalds的补丁包。不过，他说他在这两个星期的时间里收到487个补丁包。其中的大多数都有很多问题，有些补丁包来自那些本应该对内核有更好理解的内核开发者们。

坏的补丁包

Greg KH举例说明了一些他收到的坏的补丁包。其中一个补丁包被命名为：patch 48/48(一个有48个补丁集的最后一个)，但是其它的47个都没有。他还收到一堆补丁但没有写清楚先后顺序。如此，他要么猜测一个顺序，这毫无疑问会失败。另一个替代方案就是安全不管这个补丁了。另外还收到过有10个补丁的补丁集，但是2号补丁确丢失了。

Linux内核维护者的职责

Wed, 20 Jun 2012 08:48:58 +0000

原文: http://www.linuxfoundation.org/news-media/blogs/browse/2012/06/role-linux-kernel-maintainer

翻译: ykyi.net

几个星期前在日本举行的Linux大会(LinuxCon)上，我做了一个演讲，题目是"Linux内核维护者，他们在做什么，如何能够帮到他们"。

这个演讲的视频可以通过这个链接看到。如果你想要幻灯片，和我的讲演稿，可以在这个地址获得。

中山大学软件学院11级硕士研究生2012年上学期软件项目管理期末考试试题

Wed, 20 Jun 2012 05:54:51 +0000

如题，这是中山大学软件学院02年上学期期末的软件项目管理期末考试试题 for MSE 11.

The final exam of Software Project Management in the first semester of 2012 for MSE 11, Software School, Sun Yat-sen University.

一概念题，名词解释(每题5分，共30分)

WBS (Work Breakdown Structure)
CPM (Critical Path Method)
里程碑 (Milestone)
RAM (Responsibility Assignment Matrix)
SPI (Software Process Improvement)
决策树

二. 问答题(每题10分，共70分)

请具体解释项目管理知识体系的九大知识域？
如何理解迭代式开发，有何优缺点？
什么是CMMI? CMMI的五个级别各有什么要求？
简述软件项目的风险管理过程。
如何估算软件项目的成本。
项目经理应用哪些能力？为什么？
请具体解释五大项目管理过程组。

What is 802.11 and their friends.

Tue, 19 Jun 2012 11:05:52 +0000

WLAN(Wireless Lan) was invented in University of Hawaii, 1970, under the leadership of Professor Norman Abramson.The wireless network communicated using radios, without using phone lines making it easy to deploy over Hawaii islands.

Original WLAN hardware was used as an alternative to cabled network where cabling was impossible or difficult. The protocals of WLAN at that time was proprietary. Many companies and universities appealed to establish a set of protocals as industry protocals. In the end of the 1990s, IEEE 802.11(Wifi) came to satisfy the urgent need. Subsequent amendments such as 802.11a, 802.11b, 802.11g, 802.11n was published in the following years. Other proprietary protocals was then graduately replaced by 802.11 family.

关于博主About the blog master

Tue, 19 Jun 2012 06:00:33 +0000

80后IT人。2001年接触编程。

本科毕业于南京气象学院(现南京信息工程大学)。2005年。

硕士研究生毕业于中山大学。2013年。

之前供职于金山软件，目前供职于深圳腾讯。

联系qq: 16236914

Email: kamuszhou(at)qq.com

I am the webmaster. I was born in the 1980s.

I started my programming life since the year 2001, and I always keep my eyes on the constant and fast evolution occured in the cyber space.

I graduated from Nanjing Institute of Meteorology(Now renamed to Nanjing University of Info Science & Tech) in 2005 and I got the master degree in Sun Yat-sen University in 2013.

A very brief Introduction to Neural Network.

Mon, 18 Jun 2012 14:42:23 +0000

I have huge interests in the mysterious Artificial Intelligence. Because of the lack of time to devote into learning AI, I still barely know AI related theories. Tonight I read something about Neural Network, which plays a important role in the AI field.

So, what is A NEURAL NETWORK?

A neural network is a massively parallel distributed processor made up of simple processing units that has a natural propensity for storing experiential knowledge and making it available for use. It resemble the brain in two respects:

knowledge is acquired by the network from its environment through a learning process.

Interneuron connection strengths known as synaptic weights, are used to store the acquired knowledge.

Let us take the human vision as an example to demonstrate why it is necessary to study neural network. Human vision is a very complex information processing task. It is the function of the visual system to provide a representation of the the environment around us and to supply the information we need to interact with the environment. The brain accomplishes recognition task at the same time. For instance, the brain can recognize a familiar face embedded in an unfamiliar scene in shorter than a blink of eye, actually 100-200ms, whereas tasks of much lesser complexity take a great deal longer on a very powerful computer.

What's the reason makes the biological brains so efficient? How to let our machines think and do reasoning like biological brains do. The course of Neural Network has been trying to answer these questions from the day the course was established.

A typical neural network has many useful properties and capacities. 1. Nonlinearity 2. Input-output Mapping 3. Adaptivity 4. Evidential Response 5. Contextual Information 6. Fault Tolerance 7. VLSI(Very Large Scale Integrated) Implementability. 8. Uniformity of Analysis and Design 9. Neurobiological Analogy.

A easy way to add copyright information automatically into post(English Version英文版)

Sun, 17 Jun 2012 05:26:26 +0000

Several weeks ago, I decided to write about two blog posts every day. I used to write copyright information manually in the post. Apparently, it's better to let the machine do this type of trivial work automatically. So, I searched the plugins to try to find a convenient one. Indeed, I found the plugin named "add post URL" which is able to help the author to insert copyright information into the post. When I clicked the 'DETAIL' button to see more. A warning message popped up: "This plugin has not been tested with your current version of WordPress". I was scared. Because I once had a bad experience about how untested plugin ruined my wordpress as a whole. So, the option of using plugin to insert copyright information was ruled out.

为什么要虚拟化

Sat, 16 Jun 2012 03:55:35 +0000

如今，虚拟化是炙手可热的一个高频词。一些质疑虚拟化的人经常会问：我们为什么要搞虚拟化呢，计算机硬件变得越来越便宜了啊！另一方面，一些痴迷虚拟化技术的狂人们在他们的桌式机上用虚拟机运行着四五个操作系统。他们或许也有同样的疑问。仅管他们看着虚拟机里旧式操作系统，模拟出的旧式硬件，觉得非常爽非常有成就感。但是他们却不太解释得清楚究竟为什么需要虚拟化技术。那么，这篇文章将要告诉你我们需要虚拟化技术的原因。

整合 Consolidation：

使用虚拟化技术的最常见原因是需要整合：把多台机器的工作负载全部整合到同一台机器上面。在更少的物理机器上运行更多的虚拟机。但是你肯定要问：计算机已经越来越便宜了呀。没错，计算机越来越便宜了。但是如果机器非常多的话，这个价格你是绝对不能忽略的。

典型的数据中心 A Typical(full) data center

让我们来看一看当今世界的数据中心。如今的数据中心里急缺存放机器的空间，房子里满满的塞满了机器，你找不到更多的地方来添置计算机或空调之类的设施。空间利用率已经接近极限了。但是，大多数机器的资源利用率却非常地低。大概平均只有10-20%的的资源利用率。简言之，数据中心的物理空间已经饱合，但是物理机器的使用能力确远远没有利用足够。那么，如果数据中心要承担多更的工作负载，你会再建一个数据中心呢还是想办法把没有利用好的资源利用起来。

只有数据中心还有空间让你添置机器，当然多加一台机器就相当容易的解决问题了。但无论如论你放不上新的机器的时候，你应该会有很大的麻烦说服BOSS新建一个数据中心。另外一个大问题是，即使BOSS答应新建一个数据中心来解决问题，但是巨大的电力供应从哪里来呢。一个一千万瓦功率的数据中心不是说接入电网就可以接入电网的。你或许还要说服电网的领导批准提升电网的供电能力。

虚拟化是解决这个问题的最佳办法。用虚拟化把所以机器的性能都利用起来吧！

隔离硬件(Hardware Isolation)

硬件的性能每个月都在快速提高。但是，当我们把工作负载转移到一台新的服务器的时候，我们还需要先在裸机上安装操作系统，然后再配置各种软件环境，再把所有的数据转移到这台新服务器上来。忙到最后我们还要心惊肉跳的祈祷一切顺利！

如果使用虚拟化，你就不必这么麻烦了，因为不再直接与硬件层交互。你只需要在新的机器上部署好虚拟环境，再把虚拟机整个移过来。不需要再额外配置什么鬼东西，因为配置就在虚拟机里面，你已经把虚拟机整个搬来了。

历史遗留的旧操作系统(Legacy Operating System)

计算机工业走了这么多年，碰到要维护旧的操作系统并不鲜见。不幸的是，你有一个致关重要的程序只能够在这个恐龙级别的操作系统下运行。但大多数老旧的操作系统不能够在新的硬件上运行呀，你又没有办法再配置一台旧硬件的机器。

解决方案就是使用虚拟化。比如Vmware的Binary rewriting，或者Xen又或者KVM都可以。工作原理则是虚拟层模拟了简单的硬件，从你的旧操作系统看过去，多核CPU变成了老旧操作系统支持的旧时代CPU，当然频率却变快了。多核，ACPI设备发现，中断路由，支持10G以太网，支持SATA都不会成为你运行旧操作系统的障碍，因为虚拟层(Virtualization Layer)！

当然了，虚拟化本身会占用一些性能。但是因为采用了虚拟化，你才能在非常快速的新硬件上运行旧操作系统，这样得到的效率提高要远远高于在原生态支持旧操作系统的旧硬件上运行。因此，还为你节省了电费。

测试(Testing)

不管你是学习软件开发的在校学生，还是大银行的首席信息官，你一定缺少足够多的测试硬件吧。

虚拟化可以解决这一问题。在虚拟机上测试新发布的Fedora Rawhide或者Debian Unstable先，而不是直接格掉机器安装。还能给你的开发团队一把虚拟机，让每人一台虚拟机想测试什么就测试什么。

维护(Maintenace)

有了虚拟化，能方便很多方面的维护。

比如使用即时迁移技术，像Vmware的vmotion，Xen的Live Migration，你可以在保持虚拟机上的操作系统正常工作的情况下把虚拟机从一台物理机器移动到另一台物理机器。这项技术确实非常有用啊，不仅仅可以用来在你的朋友面前炫燿。

还有很多情况，你可以使用到即时迁移技术。比如物理机的硬件故障。有一台机器的CPU风扇坏了，CPU的保护系统自动启用使用CPU工作在一个非常慢的速度。那么你就可以把虚拟机即时迁移到另一台健康的机器上，然后修理那台坏的机器而不致于产生Downtime。又如，某台虚拟机的工作负载越来越大，那么你可以这台虚拟机所在的物理机上另外一些虚拟机器迁移到其它物理机上，为这台需要更多资源的虚拟机提供更多支持。有时候你需要升级某台机器的硬件，那么先把这台机器上所有的虚拟机即时迁移到其它机器，再开始你的硬件升级工作，还是没有任何Downtime。酷毙了，是吗？

节省能源(Power Saveing)

举个例子，你有100台服务器运行着各种各样的100个服务程序。但每台服务器的负载只有不到50%，那么你可以用50台物理机器虚拟出100台虚拟机运行100个服务程序。一下子节省了50%的电力，不是吗？想想，一个功率是一千万瓦的数据中心如果能节省50%的电力，这是个多么了不起的数字啊！为你节省了电费钱，还为对抗全球变暖做出了贡献。

安全和性能隔离(Security and performance isolation)

如果你采用虚拟机把不同的程序运行在不同的虚拟机里面，那么如果其中有一个程序出错，吃光了所有的内存，它也不至于影响其它程序。因为其它程序运行在不同的虚拟机里，它们仍然运行得很好，一点都不会受到那个出错程序的影响。如果这些程序运行在同一个OS下，那情况就不妙了。

一个相似的情况下，如果有一台虚拟机被入侵者攻陷，那么入侵者仅仅只控制了这一台虚拟机，暂时不能对其它虚拟机造成直接威胁。当然，这些虚拟机应该相互隔离的很好，每台虚拟机都运行着自己的内核，大多数虚拟化技术都是这样做的。但有一种虚拟化技术叫做容器技术(Container Technoloties)，如Linux VServer, Virtuozzo/OpenVZ和Solaris Zones，它们实现的虚拟化的隔离性要相当低一些，得到的好处是虚拟化自身消耗更少的硬件资源。

一个更方便的在wordpress博客的文章中自动添加版权信息的方法(Chinese Version 中文版)

Fri, 15 Jun 2012 13:17:18 +0000

从半个月前，我决定每天都写两篇左右篇客，或者原创，或者翻译。对于国内的抄袭风气，大家都很清楚，转载别人的文章时把别人的版权信息改成自己的。虽然没有非常好的办法对付抄袭。但至少也需要摆明原创作者的态度还是很必要的。

一开始，我在每篇博文里手动添加版权信息和链接。虽然工作量不算太大，但对于这种高度重复性的工作，能让机器做还是交给机器做吧。

首先当然想到的是找相关自动插入版权信息的wordpress插件，虽然也找到一款。名字叫add post，如果没有记错的话！点击Detail查看详细说明的时候发现已经很久没有更新了，而且有一个警告说对于我当前使用的wordpress版本没有经过测试。没有经过测试这句话吓到我了，我不想因为一个插件给我的博客引用不稳定性。于是放弃了使用插件。

不能使用插件那就只能自己改代码。谷歌了一下，自然搜索到前人写的相关贴子。贴子介绍说找到single.php文件。single.php文件是发贴发贴的文件，我不确定是不是文件名和所有的主题相关，会不会因为使用不同的主题，这个文件名会不太一样。然后找到这段代码：

Pagination for Multi-page posts

~~~ –>

Pages:&after=

'); // if this is a multipage post then show the navigation ?>

然后在这段代码的下面插入生成版本信息的代码。但问题是，这种方法并不可靠。非常多的博客使用了其它相关的插件会干扰这种做法。比如，我使用了一个自动生成相关文章列表的插件。于是版本信息被加到了相关文章列表下面，离真正的文章正文有很远的距离。这必不令人满意。另有文章指出可以修改function.php文件，自定义一个和the_content()类似的函数，然后把single.php中的the_content()函数替换掉来完成这个任务。我看了一下，不太满意。修改的地方超过了两个文件，觉得改动有点多。另外写的那个自定义函数对于没有太多wordpress的代码经验的人来讲并不是非常容易读懂。至少我就不明白那个自定义函数的参数的意义，应该和wordpress的标准代码相关。另外，我很怀疑如果用了这种方式，可以会使我的显示相关博文列表的插件失效。一下子没有找到非常好的解决方法。于是去吃晚饭。吃完晚饭后回到电脑前突然来了灵感。可以在用替换字符串的方法增加版权信息呀。想法是这样的。

1. 在编辑文章的时候，在你需要插入版本信息的地方加入特殊的字符串。比如我选择了在每篇博文最后敲入字符串 “copyright ykyi.net”

2. 在发表文章阶段把这个特殊字符串替换成html代码，显示你的版本信息。

是不是既简单又灵活呢！

注意要实现这个想法，需要明白 the_content() 和 get_the_content() 两个wordpress函数的区别。在调用the_content()函数的时候，文章的内容就已经打印出来了。但get_the_content()是把文章的内容做为函数返回值返回。所以在修改single.php文件时，要把 the_content()用get_the_content()函数代替。

下面贴出我的代码。看官如果需要可以修改相应部分：

$thread_content = get_the_content();

$thread_permalink = get_permalink();

$thread_title = get_the_title($post_id);

$dogeye_copyright = "

除非明确声明，本站所以文章均为DogEye博客原创或者自主翻译。
如转载，请注明出处。$thread_title $thread_permalink

$thread_content = str_replace('copyright ykyi.net', $dogeye_copyright, $thread_content);

echo $thread_content;

代码应该非常容易读懂了。而且你可以非常灵活地控制要插入的位置，还可以灵活决定插入多处版本声明。

C语言和它的安全性

Fri, 15 Jun 2012 12:28:26 +0000

原文: http://avikivity.blogspot.com/2011/08/c-assembly-and-security.html

ykyi.net 翻译。

我们看下面一个C语言的句子：

a = b + c

什么时候这个句子会造成错误呢？

a, b, c 不是我们想要的值。也就是我们把变量名写错了。
写了加法，但是我们要的不是加法。
做了加法后值溢出了。
a和b是无符号类型，而c却是有符号类型并且是负数，b+c后得到负数又赋给a.
sizeof(a)比sizeof(b)和sizeof(c)要小。又溢出了！
a是有符号型，b和c是无符号型。b+c后赋给a，溢出后，a变成负值。
a是无符号型，b和c是有符号型；再次溢出。

我们不能期望C语言本身能避免所有这些错误，但我们可不可以通过在运行时Trap上述的一些错误改进C语言使之更安全呢？结果时，除非牺牲性能，否则做不到。但我们能牺牲性能吗？

♦ 为了处理第(3)种情况，我们需要Trap所以有符号数的加法和所以无符号数的加法指令。

♦ 为了处理第(4)种情况，需要一个混杂有符号和无符号的加法指令被Trap。

♦ 为了处理第(5)种情况，需要Trap存储有符号数和无符号数的指令。在Trap中检查寄存器中的值与存入的内存地址是否匹配。

♦ (6)和(7)与上类似。

这些看似简单的问题在安全，漏洞方面经常出现。我们很难发现并修复这些问题，因为没有所需要的处理器指令。当然我们可以用已经存在的指令模拟它们。但是这样做肯定会损害性能并且使程序的体积增大。因为程序性能是可以被度量的，而度量安全问题则比较困难。结果时留下了很多充满漏洞的代码(exploitable code)。

不禁要问，为什么我们没有这些指令呢？在上世纪的七，八十年代，正在快速成长的计算机工业界面临的最大问题是性能，而不是安全。那时的代码量很小，也很容易做检查；网络还在最初级的阶段，很小，而且基本上是私有的；基本不存在恶意的攻击。

C语言在当时的作法是为了能够在适合当时所有的处理器，因此C语言的语义模仿当时的处理器指令集。之后，C语言大获成功，大量的处理器则针对C语言做优化，很多指令直接针对C语言的语义做优化或可以直接对应到C语言的语义。这样，使得C语言更加流行了。

X86的世界里有两个指令: INTO和BOUND是极好的例子。INTO(INTerrupt on Overflow)可以在一个加法指令或者减法指令之后。INTO可以用来作为上文指到过的Trap有符号加减法的指令。BOUND则对数组操作是否越界做检查。但是BOUND极少被使用。最后，在x86体系过渡到64位体系的过程中，INTO指令和BOUND指令都被只留在历史的尘埃之中了。

十分钟，教你创建自己的聊天机器人

Thu, 14 Jun 2012 07:00:59 +0000

这几天在网络上闲逛发现一个帮助你创建聊天机器人(Chat Robot)的网站。尝试了一下，很有意思呀！

关于人工智能(AI Artificial Intelligence)是我一直感兴趣的领域，但一直未能分出时间系统学习。目前为止，知道的最深入的也只是基于贝叶斯统计算法的专家系统。至于机器学习，还有神经网络哥一点都不懂哈！希望以后能有时间学习并应用。

言归正传。我发现的这个帮助你快速创建在线聊天机器人的网站是 http://www.pandorabots.com 。你在这个网站注册以后就只需要几步就可以创建一个WEB页面上的聊天机器人了。这个网站的机器人技术是基于AIML语言的。前几天写过一篇关于AIML的博文，可以参考下。前期工作来自于自由软件设区 www.alicebot.org。Pandorabots网站上的About介绍里说该网站还在继续语音识别，TTS(语音合成)等方面的研究，不过据我观赛。已经好久都没有更新了喔。

STEP ONE：在pandorabots的首页，找到Sign-up for an Account，按ctrl+F 搜索一下 Sign，就能马上定位到了。点击这个链接就可以注册一个账号了。

STEP TWO：和大多数注册过程一样，填上一些最基本的信息就注册成功。记得勾选上 By checking this box and clicking on the button labeled “Submit Account Request” you are agreeing to the Term Service 复选框。点击 SUBMIT ACCOUT REQUEST.

STEP THREE：接着网站提示: There are no Pandorabots defined yet. You must first create a new chat robot。点击 create 单词上的链接。

一篇广外女生的外贸论文的中译英.节选.

Thu, 14 Jun 2012 05:44:29 +0000

应一位广外女生的要求，帮她翻译了部分她的论文。好累好累~~诸多术语不熟悉~~

进口配额制（Import Quotas）又称进口限额制。它是直接限制进口的一种重要措施。进口配额制是指一国政府在一定时期内（如一季度、半年或一年内），对某些商品的进口数量或金额规定一个数额加以直接的限制，在规定时限内，配额以内的货物可以进口，超过配额则不准进口，或者征收较高的关税、附加税或罚款后才能进口。

进口配额，又称进口限额。它是发达国家实行进口数量限制的重要手段之一。主要有两大类：(1)绝对配额。

(2)关税配额。

5.The definition of the import quotas.

Import Quotas, namely Import Limits, which is one of the most important measures to limit import. Import quotas is defined as the direct limitation impossed on some certain

import commodity on import quantity or sum in some periods(e.g. one quarter, one half-year or a whole year). In the limitation period, merchats in limitation range is granted to be imported, otherwise, will be refused or much higher tariffs will be impossed.

There are two kinds of Import Quotas.

1) Absolte Quotas.

2) Tariff Quotas.

1．在进口配额制下管理好使用好配额，扩大出口，增加外汇

在配额制下，进口国对某些商品直接限定数量或金额，在限定范围内，货物才许可进口。因此，对出口国来说，配额用完了就不能扩大出口。即使有的国家允许超配额商品进口，而进口国则要征收高额关税或罚款，但这种关税非同一般关税，有时甚至高达百分之几百，罚款数额也很大。所以，实际上这种高额关税或罚款起到了禁止进口的作用。

这些配额都是通过谈判达成的双边协定，那么如何在配额制下管理好使用好我国的配额，扩大出口，增加外汇？

1. Manage the quotas well and make good use of it to expand export and raise foreign-currency(foreign reserves?) under the import quotas system.

Due to the fact that under the import quotas system, importing nations set a ceiling limit of the quantity and sum of the import commodity and import commodity gained the access permission only when the quota limit has not been used out. As for the exporting nations, it is not possible to expand export when no quotas is available. Even though in some nations, excess import happens only on the basis that the importing nation imposes higher tariffs, usually go up to several hundred percent, or levies heavy fines which is also very huge. Actually, it serves as a ban on imports.

1.在品种和单价方面做到对我有利，以达到扩大出口，多收外汇的目的。对配额品种首先要选择售价高的高挡商品出口。当然这要求考虑到客户的需要和国内生产的可能，但总体来说，以出口高附加值

商品为主，同时，对于资源原料型和畅销品可适当增加价格出口。

The varieties and unit price should be in our favor in order to expand the export and raise the foreign reserve. High price and high class commodities should be given high priority. The customer demands and the production capacity are surely to take into consideration. Generally speaking, high value added products should take main account of the export, resource-based goods, raw materials, and best-selling goods can be slightly exported more on the meanwhilek.

2要努力扩大配额地区的非配额品种出口。如欧盟对纺织品“篮子品种”敏感性较差，尽管协定中规定了我出口比例，但欧盟对它控制较松。这类品种我国约占二、三万吨，过去几年我国往往出口很少，数没有做足，今后应积极扩大出口“篮子品种”。但这类品种成交和出运要保持均衡，避免过分集中，而引起共同体注意和交涉。

Best effort should be make to expand export of the commodities that are not be limited by import quotas. As a example, though export quotas on "Bastket Species" are specified in trade agreement, the EU is less sensitive to it and the leash has been loosed. This kind of product accout for two or three tons in our country, which has been export a small amout in the past years and it has not been exported enough. We should expand "basket species" export positively. However, balance must be control well to prevent being intensivly centralized which will result in the EU's attention and negotiation.

3.要加强对客户的管理。配额品种一般是供不应求的商品，对进口商来说，利润是有保障的。因此，我们可以通过发放出口许可证，签发产地证和装船证书加以控制。

Customer management should be strengthed. In most cases, commodities suffering from quotas are in short supply. As for the importers, profits is well guaranted. So, we could control through taking measures such as releasing export licence, signing certificate of origin and shipment.

4.为了履行对外缔结的协定义务，管理好配额品种的出口，各业务部门必须要有一个精确的统计资料。业务部门按时上报的配额使用情况，数字一定要正确。业务部门内部也要加强统计和联系，保证成交出运数不超过配额数。

4. In order to fullfill well the trade agreement and manage well the quota commodities, every operating deparment must have prcise statistical materials. Opeating department has to report the quota usuage condition in time and the figure accuracy is a must. As inside the operating department, statistics and communications should be enforced to assure the quotas will not be accessed.

怎么编译,构建,安装,使用WinKVM

Wed, 13 Jun 2012 16:00:19 +0000

WinKVM : Windows kernel-based Virtual Machine

WinKVM Windows下台下基于内核的虚拟机(Linux的KVM的windows移植)

怎么编译，构建WinKVM

什么是AIML，人工智能标志语言

Wed, 13 Jun 2012 04:00:14 +0000

AIML是Artificial Intelligence Markup Language的缩写。这种语言基于XML，它易学习易掌握。使用AIML可以很容易的定制一个Alicebot或者从头开始创建一个Alicebot。Alicebot是种聊天机器人，参见http://www.alicebot.org/ 。

<p style="margin-left:7.5000pt;">
  下面简单的介绍下AIML的语法。
</p>

<p style="margin-left:7.5000pt;">
  AIML语言中最重要的四个标志：
</p>

<p style="margin-left:18.0000pt;">
  &middot;&nbsp;<aiml>:&nbsp;这个标签用来标志一个AIML文档的开始和结束。
</p>

<p style="margin-left:18.0000pt;">
  &middot;&nbsp;<category>:&nbsp;这个标志表示在Alicebot的知识体系里暂时无法理解的东西。
</p>

<p style="margin-left:18.0000pt;">
  &middot;&nbsp;<pattern>:&nbsp;用来描述一个简单的模式表示用户会同Alicebot说什么。
</p>

<p style="margin-left:18.0000pt;">
  &middot;&nbsp;<template>:&nbsp;用来描述Alicebot的回复。
</p>

<p style="margin-left:7.5000pt;">
  还有20余种标签会在AIML文件中经常碰到。你也可以创建你自己的&ldquo;定制标签&rdquo;。现在就开始学习使用AIML吧，这里有一个初级教程&nbsp;<a href="http://www.alicebot.org/documentation/">AIML&nbsp;Primer</a>。
</p>

<p style="margin-left:7.5000pt;">
  举例说明吧。免费的<a href="http://www.alicebot.org/downloads/">A.L.I.C.E.&nbsp;AIML</a>&nbsp;已经包含了一个基本的知识库，描述了大概41,000个category。看这个例子：
</p>

<p style="margin-left:7.5000pt;">
  <category><br /> &nbsp;&nbsp;&nbsp;&nbsp;<pattern>WHAT&nbsp;ARE&nbsp;YOU</pattern><br /> &nbsp;&nbsp;&nbsp;&nbsp;<template><br /> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<think><set&nbsp;name="topic">Me</set></think>&nbsp;<br /> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;I&nbsp;am&nbsp;the&nbsp;latest&nbsp;result&nbsp;in&nbsp;artificial&nbsp;intelligence,<br /> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;which&nbsp;can&nbsp;reproduce&nbsp;the&nbsp;capabilities&nbsp;of&nbsp;the&nbsp;human&nbsp;brain<br /> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;with&nbsp;greater&nbsp;speed&nbsp;and&nbsp;accuracy.<br /> &nbsp;&nbsp;&nbsp;&nbsp;</template><br /> </category>
</p>

<p style="margin-left:7.5000pt;">
  <aiml>标签在这里没有显示出来，因为这里只是文档的一个节选。
</p>

<p style="margin-left:7.5000pt;">
  如你所见<categoray>与</category>之间，就是描述一个category啦！每个category可以有一个pattern和一个template，还可以有一个<that>标签的，但是我不想在这里讨论它。
</p>

<p style="margin-left:7.5000pt;">
  如上的category中的pattern只能够匹配精确的"what&nbsp;are&nbsp;you"(大小写忽略)。What&nbsp;are&nbsp;you&nbsp;你不会不认识吧，好吧，直译是"你是什么东西啊？"
</p>

<p style="margin-left:7.5000pt;">
  每个category还有可能被另外一个category调用，此时使用<srai>标签，这里也不作深入讨论。可以参见<a href="http://www.alicebot.org/documentation/srai.html">reductionism</a>.&nbsp;Reductionism大根是还原论，简约化的意思。很难译出！
</p>

<p style="margin-left:7.5000pt;">
  不管哪种情况，如果这个category被激发了，alicebot就会回答："I&nbsp;am&nbsp;the&nbsp;latest&nbsp;result&nbsp;in&nbsp;artificial&nbsp;intelligence&#8230;"&nbsp;，前面<template>里面的东东。意思是：我是最先进的人工智能的产物。我能够以超快的速度和准确度模拟人脑的功能。另外，还有一些其它有趣的事情发生呢。注间到<think>标签吗？这会让Alicebot联想到这个对话的相关的一个限制，比如上面的例子就告诉alicebot，这个对向在讨论你自己。set&nbsp;name="topic",又赋值Me。于是对于alicebot的其它N多category，同样是topic的值为Me的category会被优先采纳。由此，这个机制能让你更好更准确的控制对话的流程。想想还有更多的机制呢，就看你的创造力设计一个聪明的聊天机器人啦！
</p>

<p>
  &nbsp;
</p></p>

使用Cscope阅读大型工程Linux内核的源代码教程

Tue, 12 Jun 2012 11:45:14 +0000

Cscope是一个非常有用的工具，可以用来方便地阅读很大型工程的源代码。较之使用传统的Unix工具grep，使用Cscope可以省下你一大笔时间，大大提高阅读代码的效率。

通过本教程，我会教给你如何使用Cscope阅读Linux内核的源代码。毫无疑问，你可以举一反三，用同样的方法阅读其它的大型工程的源代码，不仅仅是C语言写的工程，也可以是Java或者C++或者C#开发的工程。

STEP 1 获得源代码：

去到Linux内核的网站http://www.kernel.org下载随便一个版本的Linux内核源代码压缩包。然后解压缩，把源代码释放到某个目录。本文假设你把源代码释放到 /home/code/linux-2.6.26。

STEP 2 选择一个目录存放Cscope所需要的数据库文件。

本文假设选择用/home/cscope目录存放cscope的数据库文件和其它一些相关文件。

STEP 3 生成文件 cscope.files

在最简单的情况下，工程目录下的所有源代码都是我要关心的，于是可以跳过下面所述，简单地在工程的根目录下运行’cscope -R’命令，这样Cscope就会在工程目录下所有源代码中处理相关工作。

但是你关心的代码并必工程目录下所有的代码，你还需要排除很多目录下的大量代码该如何做呢？在这种情况下，你需要生成一个文件cscope.files，这个文件包含了所有cscope将要扫描的文件的文件名，每个名字占一行。最好使用绝对路径，这样你就可以在其它目录下，而不是现在创建cscope.files文件的目录下使用这个刚创建的数据库。下面的代码将完成这个任务（假设我要所有的java文件）：

$ cd /

$ find /my/project/dir -name “*.java” > /my/cscope/dir/cscope.files

对于Linux内核来讲，情况还要稍微复杂一点。因为我们还要排除好些文件夹，这些文件夹有存放文档的文件夹，存放脚本的文件夹，与处理器架构相关的汇编代码的目录夹，与处理器架构相关的C代码除了x86（大多数人已经仅仅对x86感兴趣），另外还会排除所有的驱动文件目录夹，因为驱动占了内核很大一部分，但驱动代码通常不是我们要关心的。如果不排除这些目录的话，cscope当然也能工作，但是却给我们增加了麻烦，因为大大增加了重复的定义出现的概率。下面看我怎么做：

$ LNX=/home/linux-2.6.26

$ cd /

$ find $LNX \

-path "$LNX/arch/*" ! -path "$LNX/arch/i386*" -prune -o \

-path "$LNX/include/asm-*" ! -path "$LNX/include/asm-i386*" -prune -o \

-path "$LNX/tmp*" -prune -o \

-path "$LNX/Documentation*" -prune -o \

-path "$LNX/scripts*" -prune -o \

-path "$LNX/drivers*" -prune -o \

-name "*.[chxsS]" -print >/home/jru/cscope/cscope.files

KVM你问我答 FAQ (四)

Mon, 11 Jun 2012 15:19:17 +0000

KVM和Xen有什么区别？

Xen是一个外部虚拟机管理程序(External hypervisor)，它承担了管理物理机器的任务并把物理机器的各种资源分配给客户机。与Xen不同，KVM本身是Linux内核的一部分，它使用Linux自己的进程调度和内存管理。这就天然决定了KVM易于使用并于体积会很小。仅管体积小，但KVM的功能确不少。比如，KVM可以把客户机从内存中兑换到物理磁盘上，如同swap普通进程一样释放RAM。KVM目前只在提供支持硬件虚拟化的x86机器上运行（如vt/svm指令集）。从这这方面讲，Xen通过修改客户机操作系统，充许虚拟机运行在没有硬件虚拟化技术的x86平台上运行。这种虚拟化技术称之为准虚拟化paravirtualization，参见另一贴：Linux的虚拟化技术。KVM在CPU级别不支持paravirtualization，但为了指高I/O性能，会对设备驱动程序支持准虚拟化。

KVM和Vmware有什么区别呢？

VMware是一个商用专用虚拟化产品，KVM是在GPL许可证下发布的自由软件。

KVM和QEMU有什么区别？

QEMU是模拟器。参见Linux的虚拟化技术 KVM & QEMU 。

KVM有windows下的移移植版本吗？

KVM你问我答 FAQ (三)

Sun, 10 Jun 2012 13:12:57 +0000

我在使用QEMU，如何知道我有没有启用KVM的硬件加速功能?

如果你怀疑你没有启用KVM提供的硬件加速功能。你可以按照下面的步骤做检查。首先，看看你有没有得到下面的提示信息：

qemu-system-x86_64 -hda myvm.qcow2
open /dev/kvm: No such file or directory
Could not initialize KVM, will disable KVM support

如果是这种情况，请再检查：

kvm模块被正确载入了吗？ lsmod | grep kvm.
查看 dmesg 的输出，保证没有这个提示信息： “KVM, disabled by BIOS”.
请确保/dev/kvm 确实存在，而且你有权限使用它。

其它诊断方式：

如果你能使用 QEMU monitor ( ctrl-alt-2, 再 ctrl-alt-1 回到 VM 的显示屏 )，敲入 info kvm 命令。如果正常的话，应该有“KVM support: enabled”这条信息输出。
在host机上敲 lsmod | grep kvm 命令，看看输出的最右栏。如果kvm在正常运行的话，这个数字不能是0。这行的数字与架构相关的模块(一般指的是kvm_intel,或kvm_amd)有联系，它显示了有多少个VM正在使用这个模块。举例说明，如果你有两个虚拟机正在使用KVM模块，host机的CPU使用的是vt技术，那么就会得到：

# lsmod | grep kvm
kvm_intel 44896 2
kvm 159656 1 kvm_intel

Six factors to help you create a great website

Sat, 09 Jun 2012 16:07:17 +0000

I’m wondering how to create a great site to put me in bucks.
I would like to share some ideas with you in the hope it would be helpful. [originally post on zausiu’s blog http://ykyi.net]

Content is the most important thing. If your website is a long-term business, don’t even think about black-hat SEO. Appropriate legal SEO is necessary, but it can’t be too over-killing. High quality content is worthier of your time and effort.Search engine’s algorithm is quickly changing. If your website is friendly to the visitor, it’s friendly to SE too.
Visitors can benifit from your site. That’s why they will come back. Useless website cannot survive in the internet world.
In the huge wave of SNS age, take advantage of the SNS is a must. As you know, something sprend in social network like infectious virus.
If you have enough time and technology support. Consider develop related desttop version application and app for mobile phone. Those apps must be able to update automatically, and you can control them in the server side. So, you can push all kinds of infomation to the apps, which will guide the users to visit your website, so your site traffic increases. What is more, the apps will be released to various kinds of download sites. Most likely your website URL will be post there which are your high-quality external links. You surely know how much the high-quality external links means to your site.
You’d better have a team, even though you are versatile and are able to play a number of roles. Remember it’s not a age for lone heroes any more, everybody is limited in some aspects.

KVM你问我答 FAQ (二)

Sat, 09 Jun 2012 08:26:26 +0000

如果我的没有root权限，怎么使用KVM呢？

最简洁的做法就是创建一个组，比如kvm组，然后把将要使用kvm的用户添加到组里面。然后用chown命令把/dev/kvm的所有组改成kvm。如果你的系统里安装了udev，你还可以通过配置udev的方式使得linux自动把新创建的设备设成正确的组。比如在ubuntu的/etc/udev/rules.d/40-permissions.rules文件中增加一行：
KERNEL==”kvm”, GROUP=”kvm”

怎么做才能得到kvm的最佳性能呢？

See the Tuning KVM page.

KVM稳定吗？

****KVM非常稳定而且已经用于工作生产环境之中。对于所有的开始工程，开发版的稳定性总是逊于稳定发行版。建议使用稳定发行版。KVM已经被使用比较长一段时间，模拟常用的操作系统和配置。一但有问题出现，开发者会在第一时间修复。参看Guest Support Status，列举了目前运行良好的操作系统。****zausiu’s blog http://ykyi.net

KVM真的可以用于生产环境吗？

****为了稳定性，强列建议你使用你使用的发行版提供的KVM模块。如前面所述，及早使用新特性总是令人开心的事情。但是，你常常要要承担一定的风险，一些未知的问题可能在使用时暴露出来。在生产环境中，最好使用你使用的发行版提供的稳定版，而开发版本，如果你愿意，可以使用在不是那么重要的环境下。

如果我用kill -9杀掉VM进程会发生什么事呢？

****From the guest’s perspective, it is as if you yanked the power cord out. From the host’s perspective, the process is killed and all resources it uses are reclaimed.
从客户虚拟机的立场来看，这就如同被拨掉了电源。从Host机的立场看，仅仅是VM进程被杀死了，这个VM进程所申请的所有系统资源被回收给操作系统。如前文所说，对于linux内核，VM进程就是一个普通的进程。

请帮助我设置客户机的网络。

****可以参考这里 Networking 设置网站，也可以找找QEMU的网络设置相关文档。

哪里有更多KVM的文档呢？

绝大多数问题都在QEMU的 documentation中被提到了，还有部分在扩展FAQ ( 已经废弃的老板 FAQ).

KVM你问我答FAQ (一)

Sat, 09 Jun 2012 05:12:04 +0000

使用KVM需要哪些准备？

****你需要一台运行Linux的x86的机器。它的CPU是有VT技术支持的英特尔cpu或者有SVM（又常被称为AMD-V）支持的AMD的CPU.

KVM支持64位的处理器吗？

****KVM支持64位的处理器！此时，你可以运行32位或者64位的客户机。

What is Intel VT / AMD-V / hvm?

英特尔VT，是什么？AMD-V又是什么？hvm是什么？

Intel VT 和AMD’s AMD-V 都指的是指令集扩展。它们在硬件层面帮助实现虚拟机管理技术。这种技术使得在虚拟机上运行的速度接近直接在真实机器上运行的速度。HVM是硬件虚拟机的缩写(Hardware Virtual Machine )则是一个生产商中立的词汇(vendor-neutral term)，它常常用来指代x86指定集扩展。

从哪里得到KVM内核模块呢？

****可以从这里获得 http://www.linux-kvm.org/page/Getting_the_kvm_kernel_modules 。

我如何知道我的CPU支持Intel VT技术或者AMD-V技术呢？

如果你的Linux操作系统比较新，尝试以下的指令：
. egrep ‘^flags.(vmx|svm)’ /proc/cpuinfo*

如果出现一些文字，那说说你的CPU支持虚拟化。你也可以在/proc/cpuinfo文件中找到处理器模块的名字，然后到供应商的网站上查询。
注意：

如果安装了Xen hypervisor，为了防止被劫持，你在dom0和domU中都得不到这些输出。dom0和domU是Xen hypervisor的术语。如果你没有安装Xen，直接忽略。
一些产商默认在BIOS定设中禁用了CPU的虚拟化支持。你需要先在BIOS中打开虚拟化支持。
如果你用的是intel cpu，对于内核版本2.6.15以前的Linux，你得不到这样的输出。如果你用的是amd cpu，对于内核版本2.6.16以前的linux，你得不到这样的输出。如果你不确定你的Linux内核版本，用#uname -r 命令查看。

出现 “KVM: disabled by BIOS” error 错误

Check if there is an option to enable it in the BIOS. If not, look for a more recent BIOS on the vendor’s web site.
在BIOS设定在找找看有没有启用cpu虚拟化的选项，如果没有，去到主板厂商的网站上面看看有没有新的BIOS发布并支持打开cpu虚拟化，那么你需要刷新BIOS.
注意：
1.对于部分硬件(如 HP nx 6320)，你需要先关掉主机电源，再打开主机电源才能使BIOS中启用cpu虚拟化支持生效。
2.BIOS的部分设定有可能与启用CPU虚拟化冲突。比如在Thinkpad T500上，启用Intel AMT技术会出现冲突。这样kvm-intel在载入时会抱怨”disabled by bios”错误。
3. 在一些Dell的硬件中，你还需要禁用”Trusted Execution”，否则不能打开VT。

在嵌入式系统部署虚拟化的八大理由

Fri, 08 Jun 2012 08:52:06 +0000

在服务器和桌面上部署虚拟化已经越来越流行。但是大多数一定没有想过在嵌入式环境下部署虚拟化。

Hypervisor(又被称之为虚拟机管理程序virtual machine monitor)如今已经在这颗星球上所有的数据中心遍地开花。因为它给数据中心带来了节省硬件，节省能源的费用，还降低了管理的成本。事实上，从兆兆级的路由器到富媒体的机顶盒，再到手机等等嵌入式系统，它们同样能从虚拟化中受益。 zausiu’s blog http://ykyi.net

因为嵌入式系统的资源非常有限。它们还通常是定制的系统，软硬件紧密结合在一起。初看来，在嵌入式设备中部署虚拟化显得过于隆重。但下文告诉你在嵌入式设备中部署虚拟化的八大理由。

更坚固

定制的硬件是非常昂贵的，如果把多种物理设备集成到一起就能降低成本。集成在一起当然比分布式的环境要简单得多。如果所有的虚拟机运行在相同的服务机上，划分网络的风险就不存在了，硬件故障也有了‘原子性’(hardware failures are atomic)，而且在虚拟化环境下已经有非常成熟的解决方案处理硬件故障，这样的故障通常会让没有部署虚拟化的系统崩溃。

更安全

试想，如果一个部署了java虚拟机的手机系统把java stack和通讯栈运行在两个虚拟机上。那么即使应用程序管理部分被攻破了，也不会危险到通迅栈。对于恶意代码，虚拟机环境是一个大沙箱。

更可靠

通过虚拟化可以把特权代码和一般代码分开，能够阻止和减少整个设备的故障率。

易于管理和开发

即使是运行实行操作系统，你不要因为那些非常有限的管理功能就心满意足了。一个运行windows的负责管理功能的虚拟机能够运行图形介面的程序，方便了用户也方便了开发者。

硬件虚拟化

VMM相当适合硬件虚拟化。它连同虚拟控制器一起动态的切分或者合并物理资源。对于大型的，分布式的嵌入式设备如路由器则可以在部署了虚拟化的情况下自由的切分或合并。Zausiu’s blog http://ykyi.net

效率

单核世界已经快速离我们远去，即将消失在历史长河中。而大多数嵌入式软件没有充分利用多核或多处理机的优势。那么，虚拟化帮助系统充分利用嵌入式系统的性能。

新特性

一些振奋人心的超酷特性，如：快照，实时迁移(live migration)，External Hibernation能够加强嵌入式设备的可用性，且方便可级。

法律问题

从商用专有代码连接GPL代码会被迫遵守GPL协议。而把GPL代码运行在虚拟机上就可以规僻GPL协议的约束了。

这篇文章译自： http://www.linuxplanet.com/linuxplanet/reports/6490/1 这八大理由中的很多条目我觉得没有说服力！

Linux的虚拟化技术 KVM 和 QEMU

Thu, 07 Jun 2012 17:36:55 +0000

Linux 2.6.20发布以后。一个称之为KVM的非常优秀的虚拟化框架加入了linux代码主干。KVM是Kernel-based Virtual Machine的首字母简写。这篇文章将在理论层面和实践层面都会简单介绍KVM是如何工作的。http://ykyi.net

简单的理论背景：
目前有几种虚拟化的方式。
其中一种称之为准虚拟化(para-virtulization)。使用准虚拟化的时候，为了达到虚拟化的目的，客户机系统必须被修改。修改后的客户机知道它运行在虚拟的环境中，与虚拟机管理程序(Supervisor)协同工作。这样的好处理较之全虚拟化，性能上有一定的优势。
另一种称之为全虚拟化(full virtualization)。使用这种技术则不需要修改操作系统。但相对于准虚拟化技术，全虚拟代技术牺牲了一些性能。因为没有客户机OS的参于，是非常困难得到很高的虚拟化效率的。但自从CPU产商在硬件层面推出虚拟化支持的时候，情况就不一样了。如Intel的VT，AMD的AMD-V虚拟化技术。KVM就是利用了CPU的虚拟化支持技术实现了。并且KVM作为linux内核的一个模块加载，天然继承了linux内核的诸多优势。基于KVM的虚拟机，被当成一个标准的Linux进程被Linux内核调度。这个KVM虚拟机看到的都是虚拟的硬件。对于一个标准的Linux进程，有两种运行模式：内核态和用户态。KVM给虚拟机进程加入了第三个模式：客户模式(guest mode)。而客户模式又有它自己的内核态和用户态。

KVM包括两部分组件：

一个设备驱动程序用来管理虚拟化硬件。这个驱动是一个字符驱动，用来管理虚拟化硬件(for managing the virtualization hardware)。
一个用户空间运行的模拟器。通常选择QEMU稍作修改。QEMU是由一个叫Fabrice Bellard的法国黑客写的。

KVM与QEMU实战,在linux下安装windows xp：

前期准备，需要安装KVM和QEMU.另外还有保证你已经编译了内核。
真正的安装超级简单。
第一步：# qemu-img create hda.img -f qcow 6G
第二步: # kvm -no-acpi -m 256 -cdrom winxpsp2.iso -hda hda.img -boot d

下面简单的解释下。
第一步创建了一个虚拟磁盘（实际上就是文件系统上一个文件而已，不过话又说回来，unix的哲学就是所有的东东都是文件。）这条命令选择了QEMU的写时复制策略。这使得这个文件会按需增长。所以一开始这个文件不会太大，以后随着你的虚拟xp占用的空间增大而增大。不过这条命令把大小限制到第大6G.
第二步：指定了win xp的镜像文件就开始安装啦！喔，这条命令使用了 -no-acpi 开关。据说acpi在QEMU中支持的不够好。不过我觉得问题应该得到解决了吧，所以也可以不用 -no-acpi。ykyi.net

于是就装好啦！真的非常简单啊~~
于是你就可以用这个虚拟的xp做一些你不愿意在真实OS上作的测试啦！或者使用只有在win下的软件。

转贴请注明出处 http://ykyi.net/2012/06/linux%E7%9A%84%E8%99%9A%E6%8B%9F%E5%8C%96%E6%8A%80%E6%9C%AF-kvm-%E5%92%8C-qemu/

Linux用两种信号量 Linux has two kinds of semaphore

Tue, 05 Jun 2012 12:24:40 +0000

面试中经常会考什么是信号量，对于linux,实际上有两种semaphore.

第一种是指一种IPC(Inter-process communication进程通讯)的方法。这种IPC是从Unix SYstem V时代开始的，System V发布时加入了三种IPC，它们是semaphore信号量，message queues消息队列，shared memory共享内存。

Linux中另一种Semaphore是内核用来同步的机制。在kernel中，semaphore通常当成一个二值信号量使用。获得信号量时有可能会睡眠，这样进程就会被调度开，放弃处理机；如果某段内核代码得到了一个信号量，这段代码还可以睡眠。这点不像spinlock，尝试得到spinlock会不停地忙等，得到spinlock后不充许睡眠。当然这个“不充许”不是语法层面的，而是应该被程序员遵守。否则整个系统的的性能就会被这代不遵守约定的代码毁掉了。

内核线程是什么东东 What is Kernel threads

Tue, 05 Jun 2012 05:45:13 +0000

有一些Unix内核，比如Solaris和SVR4.2/MP，被组织成一些内核线程。一个内核线程是一个执行上下文且可以被调度；这样的内核线程可能与一个用户程序相关联，也有可以只执行一些内核函数。上下文切换的时候，切换内核线程上下文的开销远比切换用户进程上下文的开销要小。因为内核线程通常共用一个地址空间。而Linux的内核线程则有不同。Linux的内核线程仅仅周期性的执行一个内核函数。而且，Linux内核进线程并不表示一个基本的可执行上下文。 zausiu’s blog. http://ykyi.net

Some Unix Kernels, such as Solaris and SVR4.2/MP, are organized as a set of kernel threads. A kernel thread is an execution context that can be independently scheduled; it may be aasociated with a user program, or it may run only some kernel functions. Context switches between kernel threads are usually much less expensive than context switches between ordinary processes, because the former usually operate on a common address space. Linux uses kernel threads in a very limited way to execute a few kernel functions periodically; however, they do not represent the basic execution context abstractions.

十个选择Oracle Linux而不是RedHat企业版Linux的原因

Sun, 27 May 2012 06:19:36 +0000

Linux在当今基于云的解决方案中被普通采用。而Oracle Linux目前最完整的集成解决方案。它提供了高性能和高可靠性，却只是选择Redhat Linux的花费的1/7。

http://ykyi.net 译！

原因一: Oracle Linux成本低：

Oracle Linux可以自由下载和部署。

对Oracle Linux的支持订阅(Support Subscription)非常简单且价格便宜。

支持花费(Support costs)不到Redhat的七分之一。

你不能够下载Redhat Ent Linux，除非你购买了Support Subscription。

而Redhat Ent Linux的订阅以及插件的价格都很贵。

Redhat Ent Linux的授权许可证非常的复杂。

原因二: Oracle Linux已包含管理工具。

Oracle Linux支持用户使用免费的Oracle Linux服务器的生命期管理工具，这个工具相当于Redhat的卫星服务以及相关模块。

同样的Oracle企业管理者工具也能被授权管理从应用到磁盘的整个解决方案。

而红帽的卫星服务器用户则需要分别为每台服务器都申请许可证。可想而知，花费要高很多。

原因三：Oracle Linux的高有效性。

Oracle Linux includes OCFS2 and Oracle Linux Basic and Premier Support subscribers have free access to Oracle Clusterware

Red Hat charges separately for add-ons that include clustering software for HA

怎么订阅Linux内核邮件列表

Sun, 20 May 2012 06:07:40 +0000

官方页面：

http://vger.kernel.org/majordomo-info.html

As of now, subscription support is not handled at the web!

从现在开始，订阅操作不在通过web方式操作啦。

All VGER list control activities (joining and leaving, that is) are handled via email server at address:

所以的VGER列表的操作都通过邮件的方式搞定。

majordomo@vger.kernel.org

All email sent to there must be TEXT/PLAIN, there can be no multipart messages, no VCARDs, nothing “fancy’’. In presense of such things, Majordomo will very likely do wrong thing.

所以的邮件都必须以纯文本发送。不需要multipart message，不需要VCARD，不需要花哨的东东。如果你违反了，Majordomo系统就会出错。

When you send there email, do make sure that all of the email headers, both visible and transport level, have same addresses in them. People experience problems when for example “From:’’, “Sender:’’ and possible “Reply-To:’’ headers present different addresses. The most common manifestation is complete silence from VGER!

我的梦想.(卓越领导力三千字结课作业)

Sat, 12 May 2012 14:06:50 +0000

我的梦想

虽然我的梦想没有马丁路德那么伟大，在我人生的每个阶段，我也有我的梦想。

读幼儿园之前和幼儿园时代，我的梦想是参军打仗，因为我看到的电视画面中的士兵很英勇，战争很吸引我。我要杀光所有坏人，保卫祖国！没错，小时候我的梦想竟然是要做一个血淋淋地杀人机器。现在想来真是不靠谱啊，歌舞升平的和平年代，打打杀杀什么呀？难道我要加入基地组织吗？或者去非洲参加雇佣军？

后来顺利进入小学了。虽然当时也没预见到以后国内会无仗可打，出国打仗也会毫无希望，但我确实果断放弃了以后要参军打仗的梦想。因为我突然发觉我更愿意以后做一名数学家！擦，数学家啊！！！吓死人咩！！！仅仅因为我喜欢做数学题，做同龄人做不出来的数学题，考试数学考高分，参加数学竞赛，老师表扬，同学羡慕。因些而得来了无限荣光和急剧增长的成就感，我当想就想了。以后我要成为数学家，天天解题！那时哥要是知道微积分，极数啊，场论啊，复变函数啊什么的长什么模样，我怎么会想当数学家啊！

进入中学后，数学不再仅仅是玩一些算术的小把戏了，曾经在小学时代鄙视用方程解应用题的我一度变得迷惑了，数学竟然还可以这样玩的呀。要做数学家的梦想慢慢地就被磨灭了。中学时代时要么不是想着放学后打电脑游戏，要么就是要准备升学考试或者各种什么什么考试了。我也就对未来梦想这种宏大飘渺的主题变得没什么兴趣。在三日一小考，一月一大考的中学生活中，考出好成绩，不用被父母老师骂才是最朴实最生动的梦想呀！

上到大学后，我的私人时间瞬间变得充足起来，使我有时间和精力构思对未来的梦想。在这个从少年成长到青年的关键时期，随着社会经历的慢慢丰富，梦想变得切实可操作了。大学时的梦想相当的务实，即是毕业后能像表哥那样成为一位出色的软件工程师。更具体一点，是游戏了开发工程师。现在回想，我那时真不知道架构师，工程师和码农的区别。言归正传，为了实现我小小的梦想，我在整个大学阶段确实非常用功地学习，很多同学晚上都在宿舍玩游戏，我仍然坚持去晚自习。毕业前已经写出了好几个在同龄学生中极具竞争力的PC游戏。所以，凭借我写的几个游戏作品，在大四时我毫不废力的找到了游戏开发的工作。我还记得刚到游戏开发公司上班时的兴奋心情。我想，这能算得上是实现了一个小小梦想吧。

但我的游戏开发的梦想很轻易地破灭了，而且经受的打击颇大。从那时我体会到一句话：当兴趣变成工作的以后，就大不一样了。现在回想当时对公司的失望以至对整个游戏开发行业的失望主要缘于自己的见识不够，不知道一家大型的游戏公司和小作坊型的游戏公司有相当大的差别。另外，在从学生到职业人的角色转变过程中相当地不适应。事实上，那时是有相当多的机会的呀！还有一个因素即是因为大学阶段因为在不恰当的时间帮助同学提高成绩，我的学位证被学校取消了。在毕业后的时间里，心里经常有一种失落时不时的跳出来，那就是有一天要回学校读完硕士，了结大学时没有学位证的心愿。在毕业后来到社会之中摸爬滚打的几年里，我渐渐形成了要创办自己的实业的想法。经过长年不间断的学习，我在IT技术上积累的技术已经相当全面。另外也从来没有间断过学习英语，英语水平一直在持续提高，生活阅历也更加丰富了。我的梦想，就是要有自己的实业，很可能是IT科技公司，再有其它投资组合，最终能让我实现财务自由。我把财务自由定义为，即使我每天睡大觉，我以前的劳动创造的各种盈利方式都能够帮我创造财富，带来现金流。实现财务自由后就可以做N多自己想做的事情啦！起码具备了周游世界的最基本的经济基础。在这个指导思想的指引下，我创办了一个小网站。半年后这个小网站开始盈利了，虽然很少，不过这正是我想要的Earning Machine的模型啊！即使我后来基本不去管网站，它也一直在给我创造经济收益。第一次拿到谷歌寄来的美金支票，非常开心！我做的是一个简单的粤语歌词网站，给歌词附上了粤语注音，用户点击后可以听到单个字的粤语读音。这样一个简单的网站每个月可以给我带来一百元左右的收入。我想，如果我能把流量括大一百倍，那每个月就轻松有一万元收账嘿嘿。仅仅就这个非常简陋的小网站来讲，我觉得把流量括大一百倍并没太大问题。因为我还没有围饶社交网络做推广，也没有给网站做用户体验，还有很多功能也没有做。而我观察的一个类假的相关网站的网络流量竟然是我的几百倍。我觉得如果投入时间就能超越它。但我没有继续做下去！不是我没有执行力，我不太想做WEB方面，我做做ARM嵌入式方面，我觉得在这方面一定会有更多更好的机会。

去年下半年又返学校读书了，明年六月能顺利毕业。届时就能完成本科时的小小心愿，某种程度上也算是圆一个小小的梦想。在中大读软工硕士的时间里，仍然疯狂地学技术和英语，并跟进日新月异的IT业界的新闻。脑子里基本上有一些想法，我还需要认识更多的高手，除了互联网领域肯定还有其它方面的创业方向。昨天晚上，与一位以前在毒霸时相识的老同事聊天。它是位出色的逆向高手，离开珠海后，他在广州与朋友创办了一家做网页游戏的游戏公司，撑了近一年经营不下去。于是他去了深圳腾讯做回逆向工程老本行，但他只在腾讯做了七个月又离职了，和朋友去上海二次创业，仍然做网页游戏。他说他离职的原因就是放不下他心中的梦想。其实我也一样。在人生的每个阶段，不间断地为实现心中的梦想而努力这应该是人生的部分意义吧。如今，我思考我与我的梦想的距离。我具备了很广泛的计算机知识，从硬到软，从网络到桌面到WEB到嵌入式，具备了相对不错的英文水平。但我还欠缺广泛的优质的人脉关系，这方面还需要不断的积累。今年下半年，我会找我感兴趣的方向的兼职，希望能认识一些优秀的朋友。我们之间分享信息和体会，互相为实现各自的梦想提供支持。

我非常希望能在四十岁前能实现财务自由梦想。虽然这样的想法听起来太多务实，还带着一点铜臭味。但我却也无需过多解释，每个人都能够理解。我是普通人，我只希望能给家人带来健康和幸福，希望有能力帮助保护我身边重要的人，所以我务实，而不是关注世界和平，关注拯救地球，关注消灭战争和贫困。

如果财务自由的梦想不能实现呢？于是我一直在工薪层卖不断出卖劳动力生活，终未能实现目标呢？虽然为了实现梦想，我们当然要付出百倍的努力，但成功往往不仅仅受制于主动的努力程度，也受制于客观的各种不可抗条件。所以，对于每一个心怀梦想的年轻人，我觉得都应该有良好的心态面对可能的失败。我会努力追逐我的梦想，但如果做不到，我觉得不能丢掉两样东西，一件是乐观的心态，另一件是健康的身体。这两件东西是能完成任何一个目标的最低配置。

如果我能及时实现财务自由我梦想。那我一定要开始我的周游列国之旅，还要认真学一门乐器，这才是真正的生命哈哈！在充分的实现的实现了自我价值的同时，我一定会把更多精力投入到回报社会中来。想想比尔盖茨的故事。比尔盖茨在今年年初《高端访问》节目上如此表示，“我的新梦想是希望能够平等地对待生命，人们消除了偏见，让这个世界变得更加公平。希望20年后，我所提到艾滋病、疟疾、结核病等重大疾病都彻底的消失，让贫困国家的人民摆脱贫困，获得公平对待的机会。”很多富有的西方商界人士在功成身退后都会把很多精力用于经营慈善基金。这大概是因为基督教主张账富源于社会，又要回报社会。我不信仰基督教，我也不会有比尔盖茨那样成功，但我非常认同这样的普世价值观，我也会力所能及的回报社会。或许我可以做义工，也可以资助贫困地区的教育。

希望我能有幸实现我的一个又一个梦想！

(完)

想钱想疯了.

Thu, 19 Apr 2012 05:35:29 +0000

昨晚梦见自己开了一辆敞篷跑车~~

好奇怪呀。我从来都对小车不感兴趣呢。

三年前。珠海。与我同一天生日的一个好同事也离职了，准备去上海。

他说：“我要买辆兰博基尼”。

我居然不知道兰博基尼是什么。~~

好久之前就想：我要创造出好几个Earning Machine。于是不管你到处游玩，做各种自己想做的事情，Earning Machine都会自动给你带来收益。啊哈哈哈~~自由啊！！！在这一指导思想下，确实实现了一个小小的试验性质的小案例，称之为Earning Machine Version I，但实在实在太少收益了。多次考虑过增强这个版本，但要投入太多时间，更有说服力的原因是在这个过程中积累的技术经验是我不感兴趣的方面。我还是面向技术的思维方式啊！

学校的生活令我相当地满足呢，除了经常想到持续减少的银行账户余额，感到严重没有安全感。

这种不安是我疯狂看书的动力之一。我迫切希望快点完成读书的计划，在下半年再回到社会，找个工作，认识一班新朋友，或许能够有更多的思路实现Earning Machine Version II。

之前还想，如果读博士学位，成为某个方面的资深专家，能不能把读博时的成果转化成巨大的经济收益呢？我问Dr. Woo，你能把你的学术成果转化成真金白银吗？Dr. Woo说现在很难。

两三天前，广州好热好热。我以为夏天到了，于是把被子收了起来，铺上凉席。结果当天晚上就下雨又天冷了。靠~~连续三天五早晨时被冻醒，于是穿多件衣服睡，其实也满舒服的！！！应该再过几天又会很热了~~

哎。时间资源实在太有限了。我下载了The Secret的英文原版打印出来了，才看了不到15页。买了笛子入门基础书，看了不到5页，有些东西看不懂。

还有一个月就要考BEC高级了，希望自己能通过。应该能够通过吧~~我想！！！所以，暂时英语优先级最高分到最多时间资源，专业技术优先级其次，其它事情就放放吧~~~

虽然阴沉沉地下着雨，去图书馆的路上却心情非常不错，因为觉得很满足，我在做我想做的事情！

写了一个输粤拼查汉字的功能

Tue, 03 Apr 2012 07:00:11 +0000

虽然只是个小小的功能。但写出来却也不是一两个小时的事情，写了四个小时才写完~~~有个缺陷就是：对多音字支持得不够好~~

主要技术障碍来自于对javasript不熟悉，用firefox浏览器调试时浏览器总是缓冲旧的javascript文件。

http://ykyi.net/jyutping2char.php

一直以来都有网友抱怨没有办法发音~ 这是因为目前的发音是通过flash技术实现的，但很多手机平台上的浏览器不支持flash技术，比如苹果的移动平台就不支持flash。

鉴于HTML5是未来互联网的行业标准。我在计划写一个HTML5的版本。但是没有时间表约定~我也不知道什么时候可以完成。

SWOT分析法

Tue, 20 Mar 2012 12:26:41 +0000

SWOT

SWOT分析法又称态势分析法。早在20世纪80年代初由旧金山大学的管理学教授提出，它是一种能够较客观而准确地分析和研究一个单位现实情况的方法。

S.W.O.T.分别是是英文单词STRENGTHS(优势)，WEAKNESSES(劣势)，OPPORTUNITIES(机会)，THREATS(威胁)的首字母缩写。

其中竞争优势S可以是：技术技能优势，有形资产优势；无形资产优势；人力资源优势；组织体系优势；竞争能力优势。竞争劣势W可以是：缺乏具有竞争意义的技能技术；缺乏有竞争力的有形资产；无形资产；人力资源；组织资产。企业中的机会O可以是：客户群的扩大趋势或产品细分市场；技能技术向新产品新业务转移，为更大客户群服务；前身或后向整合；市场进入壁垒降低；获得购并竞争对手的能力；市场需求增长强劲，可快速扩张；出现向其他地理区域扩张，扩大市场份额的机会。企业生存的外部威胁可以是：出现将进入市场的强大的新竞争对手；替代产品抢占公司的销售额；主要产品市场增长率下降；汇率和外贸政策的不利变动；人口特征，社会消费方式的不利变动；客户或供应商的谈判能力提高；市场需求减少；容易受到经济萧条和业务周期的冲击。其中的SW属于内部因素，OT属于外部因素。

企业进行SWOT分析时先罗列组织的内部优势和劣势，外部可能的机会与威胁。其次，对SO，ST，WO，WT策略进行甄别和选择，确定组织目前应采取的具体战略与仿真；优势、劣势与机会、威胁相组合，形成SO、ST、WO、WT策略。一共三个阶段。更详细的展开说。

在第一阶段运用各种调查研究方法，分析出公司所处的各种环境因素，即外部环境因素和内部能力因素。外部环境因素包括机会因素和威胁因素，它们是外部环境对公司的发展直接有影响的有利和不利因素，属于客观因素，内部环境因素包括优势因素和弱点因素，它们是公司在其发展中自身存在的积极和消极因素，属主动因素，在调查分析这些因素时，不仅要考虑到历史与现状，而且更要考虑未来发展问题。

在第二阶段构造SWOT矩阵。将调查得出的各种因素根据轻重缓急或影响程度等排序方式，构造SWOT矩阵。在此过程中，将那些对公司发展有直接的、重要的、大量的、迫切的、久远的影响因素优先排列出来，而将那些间接的、次要的、少许的、不急的、短暂的影响因素排列在后面。

在第三阶段制定行动计划。在完成环境因素分析和SWOT矩阵的构造后，便可以制定出相应的行动计划。制定计划的基本思路是：发挥优势因素，克服弱点因素，利用机会因素，化解威胁因素；考虑过去，立足当前，着眼未来。运用系统分析的综合分析方法，将排列与考虑的各种环境因素相互匹配起来加以组合，得出一系列公司未来发展的可选择对策。

总言之：SWOT是一种分析方法，用来确定企业本身的竞争优势，竞争劣势，机会和威胁，从而将公司的战略与公司内部资源、外部环境有机结合。因此，清楚的确定公司的资源优势和缺陷，了解公司所面临的机会和挑战，对于制定公司未来的发展战略有着至关重要的意义。

gcc的-E选项什么意思

Wed, 22 Feb 2012 05:37:54 +0000

gcc的-E选项可以为你生成预编译后的文件。预编译后的文件将把c文件中的宏以及该文件包含的所有头文件展开。这样就没有了一层一层进入嵌套包含的头文件。下面是一个使用gcc的-E选项的例子。

下面是来自gcc mannual page的解释：

-E Stop after the preprocessing stage; do not run the compiler proper. The output is in the form of preprocessed source code, which is sent to the standard output. Input files which don’t require preprocessing are ignored.

$ gcc -E drivers/char/mydrv.c -D__KERNEL__ -Iinclude -Iinclude/asm-x86/mach-default > mydrv.i

其中的-I选项告诉编译器在哪些目录中搜索所需要的头文件。

还可以用gcc的-S选项生成汇编码的文件。如：

$ gcc -S drivers/char/mydrv.c -D__KERNEL__ -Iinclude -Ianother/include/path

ykyi.net

读论文宏观层面的软件演化

Wed, 22 Feb 2012 05:30:46 +0000

软件工程进展读论文报告

论文：Macro-level software evolution: a case study of a large software compilation (宏观层面的软件演化：举例研究一个大型软件的编译)于2008年11月29号发表于实证软件工程。

论文的背景和动机：

软件演化(Software Evolution)一般研究的是由相互合作的团队开发的单个的软件产品。但是越来越多的软件系统包含了大量了不同的应用和运行库。很多这些应用和运行库是由不同的团队面向不同的目的开发的。这种大型软件系统是如何演化的呢？他们有些什么特性特点呢。但要研究这样的大型软件系统需要有这个系统所涉及的所有应用和库在各个时间点的源代码。这并非一件易事。因此才鲜有研究文献涉及该类型的系统。

这些年，很多大型自由软件系统取得了巨大成功，例如Fedora Linux, Debian GNU/Linux, FreeBSD, OpenBSD。这些大型自由软件集成成百上千独立应用和库，并且几乎所有自由件的授权都充许自由得到相应的源代码。这为我们研究大型软件系统的演化提供了必要条件。

构成大型软件系统的各个工程是独立开发的(某些软件系统把这些独立开发的工程称之为包)，但从整个软件系统的视角来看，它们之间却存在复杂的依存关系，甚至在某些情况下会是冲突关系。因此，单个的研究某特定工程的演化与在整个软件系统中研究软件的演化是不同的。

论文旨在通过分析一个大型自由软件系统的演化来揭示大型自由软件系统的一般规律以至私有大型软件的某些规律和特点。

论文中实证研究的定义、规划、执行与分析：

Debian GNU/Linux是一个非常流行的大型软件系统。它包括了各种大大小小的应用和库，其中一些演化的非常迅速，其中一些又长期没有变化，不断有新的包加入该系统又不断有过时的包被抛弃。仅管这些包是相互独立开发并自我演化，但在Debian系统中，它们之前有着非常复杂的关系。这个复杂关系随着Debian系统的演化而变得更加复杂，使之越来越难以维护。

[定义]

这篇论文，即以Debian软件系统为例，主要考察了九年以来Deiban系统中包的总数，包的大小，开发语言，包之间的相互依赖性等多个指标，在宏观上研究整个Debian软件系统的演化。最终得出一些大型自由软件的特点，分析这些特点能指导单独的软件研发使之能更好的集成进大型系统中。

[规划和执行]

Debian组织成一个个包(package)，一般地讲每个包对应于一个应用或一个库，少数情况下对应于文档或其它。包分两种，一种是包含运行的二进制文件的包，另一个是源文件包。源代码包在构建以后通常生成一个或多个二进制包。Debian为每一个发行版本维护了一系列配置文件，这些配置文件设定了每个发行版所需要的运行环境，包含了哪些包。而每个包的配置文件也约定了它所依赖的其它包的关系。

这份报告研究了Debian从2.0到4.0的所有稳定发行版号，即2.0,2.1,2.2,3.0,3.1,4.0。对于每一个待考察的版本，配置文件被事先写好的脚本分析，把分析到的数据存入数据库中。然后，每一个源码包被自动获取，源代码行数被SLOC工具分析得出；源代码所使用的编程语言也用SLOC工具识别到。而包与包之间的依赖性亦可由Debian发行版的配置文件中记录的Depends,Pre-Depends,Suggests,Recommends字段得到。这些信息被分析出来以后，包与包之间的依赖关系由一个有向图描述出来。有向图中的结点表示一个包，连接结点的边表示包与包之间的依赖关系。每个待研究的Debian发行版都会生成一个这样的IDG(Inter-Dependency Graph)，通过运用有向图的算法可以得到很多研究关心的数据，比如最流行的包(The most popular package)。

[分析]

发行版总大小

结果显示每隔两年，发行版的大小(统计发行版的所有源代码行数)就会增加一倍。截止2007年的Debian 4.0，已经共有4亿行代码和1万个包。如此大的规模会为未来的继续发展带来不小的麻烦，在最新的发行版中已经可以看到超大规模的几数级增长已经给某些时间点带来了延迟。

包的大小

而包的平均大小指标在九年内几乎维持不变。因为软件系统的总代码量迅速增长而平均包大小不变，这意味着越来越多的包被增加到系统中。Debian .4.0的包数目是Debian 2.0的包数目的10倍。为了应对包的不断增多，Debian系统需要迅速增加包维护者以及每个维护者需要应对的包数目。包数目的迅速增长也是一个非常棘手的问题，特别影响了包维护者的相互配合。

包的维护

Debian维护者的任务之一就是跟踪新版本的软件包，给它们重新打包，更新相应的包描述。一但一个新版本的包发布了，包的名字就会相应变化。因此可以通过分析发行版的包的名称确定软件包有没有被维护过。

分析数据后显示Debian 2.0的1096个包里面有721个可以在4.0中找到。这意味着Debian2.0中只有30%的包在九年后的Debian 4.0中被移除。再之，Debian 3.1的10106个包中，而在4.0中仍然存在的有7300个，这个比例也大概是30%。

对于没有改变过的包。Debian 4.0中有132个包与Debian 2.0中毫无改变。换言之，Debian 2.0中不少于15%的包在九年后仍然没有任何改变在Debian 4.0中。

必须指出的是未改变的包所包含的文件数目并不能反应所有的未改变的文件数目。后者的数字应该高一些：有相当多的文件在Debian的各个发行版之间没有改变，即使它们所属的包的名字变化了。

开发语言

统计数据显示Debian各个发行版中最多使用的开发语言仍然是C语言，并且较之于第二名优势明显。但对于C语言，在第Debian 2.0中，C占了77%的份额；到了Debian 4.0，C语言的份额下降到了51%。而对于C++，则是从2.0时占6%的市场份额上升到了4.0时的19%。总体上看，C语言的重要性一直在相对减弱，而C++和其它一些开发语言都保持了一定增长的趋势。必须说明的一点时，仅管C语言的份额在下降，但从C语言代码绝的绝对数量上看仍然在快速增加。

Shell语一直处在第三的位置，因为这种语言在几乎每个包中都有。从大量的小尺寸包到重量级的包，Shell无所不在。

另一个值得关注的必然是Java。在Debian 3.0时，Java编写的应用仅仅占到0.5%。到了Debian 3.1发布时，这个数字飞速上升到1.7%，到了Debian 4.0時，增加到了3.1%，稳定地占据了第四的位置。Java的快速增长得益于几个大型应用使用Java语言进行开发，比如：Eclipse和Azureus。实际上，Java还是被低估了。因为授权许可证的问题，包含大量Java代码的Sun JDK和Sun JRE没有统计在内，而其它语言则至少包含了一个常用的开发环境。

就代码量而言，一些比较生僻冷门的语言也占据了比较明显的份额。这是因为虽然这些生僻语言仅仅出现在少量包中，但这些开发包的尺寸却很大。比如，Ada语言在Debian 3.0中有57万行代码，其中的43万行都来自于Ada的编译器，开发库和开发工具。

通过观察开发语言的使用率趋势，可以估算出有多少开发者比较熟悉某种开发语言。同时，不同语言的不断演化也反映出自由软件在开发语言层面的变化。

怎么为Linux源代码生成补丁

Wed, 22 Feb 2012 05:27:48 +0000

怎么为Linux源代码生成补丁

用diff命令来为linux源代码生成补丁。如：

$ diff -Nur /path/to/original/kernel /path/to/your/kernel > change.patch

注意原始的源代码在前，更改后的源代码在后。2.6.x内核的补丁包提交约定指出你需要在每个patch后面写上这样一行：

Sined-off-by: name

这样注明这个补丁包由你制作并贡献给社区。

参看 Documentation/SubmittingPatches可以知道更多关于提交linux源代码补丁的内容。

参看 Documentation/applying-patches.txt 可以知道更多如果打补丁包。

业务连续性读书报告

Fri, 13 Jan 2012 11:52:01 +0000

第一部分概述

1 什么是业务连续性

业务连续性就是为了应对系统宕机，无法接受的性能下降之类的问题。

2 为什么要有业务连续性

因为如果系统宕机会造成无法估计的巨大损失。怕你不信，PPT里画了张表，列举了几个行业宕机会造成的损失估计。最低的一般零售业每小时损失一百万美金；损失最大的是投资银行，每小时造成接近七百万美金的损失。

3 恢复时间 Recovery Time

Recovery Time includes：1. Fault detection 2. Recovering data 3.Bringing apps back online。

4 灾难恢复和灾难重启的区别

灾难恢复是在人为干预下使用备份技术恢复数据把数据恢复到备份的某个完整点。而灾难重启则是重启镜像数据和应用程序。

5. 造成系统宕机的原因

有人为因素，系统本身的原因，支持系统的外围设备的故障(比如电网断电)，另外还有自然灾难，战争什么的。苦逼的伊斯兰世界天天哭喊着要圣战啊。

6. 业务连续性和灾难恢复

业务连续性是一盘大棋，包括：计划，准备，从灾难中恢复。它侧重在预防。而灾难恢复计划(Disaster recovery planning，abbreviated as BCP)应被看成业务连续性的一部分。灾难恢复侧重于事发后采取的措施和行动。

7. 业务连续计划(BCP)

界定关键业务功能；收集当前业务流程的数据；风险管理；制定应急预案(Contingency Plans)和灾难恢复计划(DR Plan)；培训；测式；维护。

8. 业务连续性计划的生命周期

包括五个阶段。1. Implement, Maintain, and assess 2. Objectives 3. Analysis 4. Design & Develop 5. Train, Test & Document.

9 单点失效

这个概念N多学科里都有提到哇。顾名思义都知道单点失效是什么咯。解决的方法就是冗余！PPT里列举了HBA失效，交换机/阵列端口失效，磁盘失效，主机失效，站点/存储阵列失效。

10 业务连续性技术的解决方案

有三种。 A. 本地复制 B. 远端复制 C. 备份/恢复

11 EMC的相关产品

EMC在业务连续性方面的产品叫PowerPath。PowerPath是个基于Server的软应用，它在HBA和存储子系统间提供了多通路。嗱，它提供冗余通路。好明显冗余是为了防止单点失效；还提供了负载平衡；应用层的透明性。这个东东增强了数据的有效性和可达性。

第二部分解决方案

A) 备份和恢复

1. 备份是数据恢复和恢复的目的，可以使用的额外副本。主副本丢失或损坏时，使用备份副本。

2. 备份恢复的策略：复制数据，反射（或快照）后复制，远程备份等。

3. 备份计划的原因包括以下几个方面：硬件损伤、人为因素、应用程序崩溃、安全机制失败、自然灾难、定期的以及公司的需求。

4. 数据库备份方法：热备份，生产不中断；冷备份，生产中断。

5. 备份粒度和等级：全备份，累积备份，增加的备份

6. 备份架构拓扑，3种基本备份拓扑：基于直接附属设备的备份，基于局域网的备份，基于SAN的备份。

7. 备份媒介，磁带，磁盘。

8. 管理备份过程

备份应用程序接口一般包括两类，CLI和GUI。

备份报告：目的是要便于阅读和提供重要信息，如：备份的数据量；完成备份数；备份不完整的号码（失败）；可能发生的错误类型。

备份日志的重要性：从日志中我们可以看到备份操作的强度和完整度等等，备份日志丢失，软件无法找到确定的备份文件来进行恢复。

B) 本地复制

1. 复制是产生拷贝数据的过程。

2. 备份关注两方面的，可恢复性，一致性。

3. 文件系统复制。

4. 数据库应用程序复制，包括数据和日志。

5. 本地复制技术，基于主机：基于存储阵列，分别举了几个例子。逻辑卷管理（LVM），基于镜像文件系统快照。

C) 远程复制

1. 学习目标：阐释远程复制的概念，能从各方面讨论基于主机和基于阵列的远程复制技术。

2. 同步复制：确保源和远程副本，在任何时候都相同的数据

3. 异步复制：数据缓冲，并且送到远程

4. 远程复制技术包括：基于主机的复制；基于阵列存储设备 zausiu's blog

/////////

介个是EMC存储课的作业.

In the flesh 本人地；活生生地。及其它与flesh有关的短语。

Sat, 07 Jan 2012 13:42:07 +0000

<绝望的主妇>第二季第十九集中，susan 的感情进展地很不顺利。一天她独自去电影院。不巧的是，她在电影院里撞见了mike,还是和别的女孩一起来的。这真是无巧不成书。她为了避免尴尬赶快向旁边一位男士求救。还好他很配合，也很幽默。他说：Wow, i can’t believe I’m finally seeing the man himself, in the flesh.

http://ykyi.net 在这句说话里面，in the flesh means present and alive before one’s eyes or in person(活生生地在某人眼前或本人地)，也可以简单理解为”活生生地，本人地”

例如： She is even more beautiful in the flesh. 她本人更漂亮

一定要学会这句话喔。这可是在看照片时常用的啊。哈哈。

flesh可以指“肉，肉体”

Hi, what makes u lose so much flesh. 嗨，是什么使你变得如此消瘦。

The spirit is willing but the flesh is weak. 心有余而力不足。

**flesh and blood 可以用来泛指人体，人性(The human body or nature).
**

The work is more than flesh and blood can stand. 这项工作非人能忍受。

英语里几个和knock有关的短语 knock off; knock out; knock up; knock yourself out

Sat, 07 Jan 2012 13:10:20 +0000

knock是个普通的动词，但在日常口语中经常出现。

Knock off : ‘住手’的意思！ Betty Applewhite把自己弱智的儿子caleb囚禁在basement，caleb总是不断地击打镣铐发出哐啷的声音。另一个儿子Matthew无法忍受时对地下室喊到： Knock it off !

Knock out:

拳击双赛中的”KO”，即把对方击倒，即 knock out 的缩写.

但数学老师说”we can knock out x and y”这里的knock out 则是“消去”的意思。http://ykyi.net

knock-out 作名词解时却是“美女”的意思。 She is a knock-out. 她是个美女。

Knock up:

Knock up这是一个略显粗俗的美国俚语，意思是“to make sb. pregnant”(使某人怀孕)例如：

You are so irresponsible, if u knock her up and then disappear.

又如： The young girl said she was afraid of getting knocked up.

在英式英语中，knock up 和 knock out 有相同的意思，表示“使筋疲力尽，使累垮”

例如：This physical work knocked me up. 这个体力活使我筋疲力尽了。

A slap on the wrist 轻微的惩罚

Sat, 07 Jan 2012 12:24:03 +0000

<绝望的主妇>第二季第九集中。Lynette找到stu,鼓动他上司Ed说明自己被解雇的真正原因是女上司Nina对他的性骚扰，Stu为保全工作决定找Ed摊牌，但同时又担心Nina的处境。

So would Nina get in trouble ? 那么Nina会有麻烦吗？

well, I‘m not gonna lie to u. There is a possibility she’d get a slap on the wrist. http://ykyi.net 我不想撒谎，Nina有可能会受到轻微的处罰。

这里 a slap on the wrist中的slap就是打一下。比如说，a slap on the face就是打耳光。 a slap on the wrist 就是在手腕上打一下。在手腕上打一下并不痛。作为习惯用语呢， a slap on the wrist 就是”轻微的惩罚”。

比a slap on the wrist更轻的叫做“token punishment”.象征性惩罚。

You got off easy this time, but stealing is a serious crime and next time it won’t just be a slap on the wrist.

stab someone in the back 出卖别人

Fri, 06 Jan 2012 17:31:57 +0000

《绝望的主妇》第2季第22集，大伙忙着帮susan收拾大火过后的残局，无意之间susan发现只有edie站在街对面袖手旁观，悠闲地吃冰棒(popsicle)，还洋洋得意地盯着susan. Susan当即像是明白了些什么，随后便跑到Edie家去想问个究竟…

http://ykyi.net

没想到这一对质，Edie承认了她所做的一切，但她却振振有词，原因是她看了susan之前写给她的道歉信。susan做梦也想不到那封信怎么还会到Edie的手里。Mike花了大价钱赶走了私家侦探Oliver. Susan又想尽一切办法引开邮递员Gus的注意，偷出了那封信,没想到老天捉弄人，在Julie回家后以为是邮递员弄错了，误把给Edie的信放在自己家里的信里了，于是她又给放了回去。

http://ykyi.net

当susan还是一头雾水的问”letter? what letter?” 。还是 Edie理直气壮地告诉她：The one where u admitted to stabbing me in the back by sleeping with Karl (在那封信里你承认了你在背后出卖我，与Karl睡觉。)

Stab someone in the back 是指在背后暗箭伤人，出卖某人的意思.

I cannot believe my best friend stabbed me in the back. 我不敢相信我最好的朋友竟然出卖我。

http://ykyi.net

顺便提到另一个谚语： Better an open enemy than a false friend. 公开的敌人胜过虚假的朋友。

英语习语中的Bite

Thu, 05 Jan 2012 16:33:42 +0000

Bite这个词本来很简单，但是在实际运用中，可以活用的地方有很多。例如，在《绝望的主妇》第二季第二十集中，一次，Lynette在帮助上司Ed与妻子进行网络聊天时，他模仿Ed的口气暧昧地说： i will bite you good. (我会把你咬得全舒舒服服的.)

http://ykyi.net

t Susan就像猫和老鼠一样，好像注定是天敌。Edie口中最尖酸的话好像都指向了susan,有一次，她脱口就骂Susan： You bitch! Susan总是要内敛一些，她没有直接骂Edie是bitch,但动动却表达了同样的意思。因为她迅速地回击说: Bite me ! 也就是说：你咬我吧。你能把我怎么样?

Bite me 是对对方的一种挑衅。

Bite 可以利用的场合远不止此。如果你早上起晚了，而上班时间马上又要到了，那么早点又不能不吃，你可能会随便吃一口面包，这样你可以说：I will take a bite of bread this time.

英语中，可以用go for a bite表示“出去吃饭”例如：

what’s up ? 干什么呢？

Well, i was wondering if you’d like to go for a bite. 嗯，我在想你是否想出去吃饭。

再如，有一句广告词上写着: save those leftovers and go out for bite on Friday.（星期五不吃剩菜，出去吃）

http://ykyi.net

还有四个与bite有关的短语，值得一学。

**All bark and No bite. **什么意思呢？中国的俗语里面也有类似的说话，即“叫唤的狗不咬人(Barking dogs seldom bite.)” All bark and No Bite的意思跟这个很相似，即“嘴上说说，实际上不会怎样””雷声大，雨点小。”例如： The new manager threatened to fire me but i know he won’t do it; he is all bark and no bite.

Get over somebody

Sat, 31 Dec 2011 07:41:17 +0000

短语: get over 什么意思.

I know you’re trying to get over Morty, but this is not the way to do it.

我知道你在尽力忘了Morty,但是，这不是正确的作法。

在这里get over 的意思是”忘却”，它还有”结束；熬过；康复” 的意思。如果说 He finally got over his divorce,那就指他人离婚中恢复过来，不再为此事烦恼或煎熬了，已回到正常的生活中了。

Even though we have broken for such a long time, I still couldn’t get her over.

虽然我们已经分手很长时间了，可我还是忘不了她。

Get over除了当”忘记”讲，还有一个意思”克服，忍受”相当于over come.例如:

No matter what it takes, we must get over this difficulty.

It took me a long time to get over my flu.

A pillar of salt 什么意思. 盐柱子是什么意思. lot’s wife什么意思.

Fri, 30 Dec 2011 13:52:46 +0000

<绝望的主妇> 第二季第十一集中，Bree对Andrew和男友Justin在自家前院的暧昧行为提出了批评，没想到反遭讥讽：“Oh, and you didn’t turn into a pillar of salt. Good for you。" 噢，还好，你没有变成盐柱子。

怎么会变成盐柱子呢？原来这个典故来自于圣经里的故事。

这个故事是这样的:

当上帝开始摧毁罪恶之城所多玛和俄摩拉城时，他派出两位天使力劝善人罗德及其家人赶快离开，并警告他们在逃跑时千万不要往回看。但是罗德的妻子特别好奇，她想知道这座故乡城市到底会发生什么。在她回头看时，她变成了一个盐柱子。

所以英语中就有了Lot’s Wife和a pillar of salt来指代"分好奇的人"。

另外 ykyi.net 还有两个关于salt的短语.

worth one’s salt 是指称职，有能力，能胜任的意思。原因是盐曾作为工资支付手段，工资金salary也就是源于此。例如: That actor is not worth his salt. (那个演员不称职。）

rub salt in an old wound 表示"故意提及伤心地往事" 例如:

Do you remember that time you were giving a speech and you dropped your laptop computer?

Oh, please, let’s not rub salt in old wounds.

英语习语中Dead的用法

Thu, 29 Dec 2011 10:00:33 +0000

绝望的主妇第一季第13集中Lynette对Tom说的非常绝妙的一句话: I guess i just got so upset because —- oh, whatever, let’s not beat a dead horse, it’s over, Im sorry, good night. ( 想那事让我这么心烦就是因为—-哦，随他去吧，事已至此，也别白费口舌了，这件事到此为止，我很抱歉。晚安。)

zausiu’s blog http://ykyi.net

这句话中的beat a dead horse 这个表达非常形象，这里的beat也可用flog替换。大家想象一下，用鞋子抽打死马让它驰骋，就是再大的力也没有用。因此这个表达用来表示”徒劳，作无用功”或是指”对已摒弃或认可的活动信念徒费精力”。英语中还有很多跟dead用关的用法。

老友记中Earl先生想自杀的原因之一就是他觉得自己从事一个dead-end job (没有前途的工作)。

dead-end 是美国俚语，意思是死胡同，与中文里穷途末路相似。

美国作家Sidney Kingsley于1935年创作现实主义作品Dead End<死巷>。小说反映美国纽约大城市贫民窟中青少年的生活，1937年被编成电影Dead End Kids《死巷小子》。之后dead-end kid就是“穷孩子，浑小子或没有出息的男人”的意思。

The City Hall is more often a dead end than a stepping-stone for improving one’s political careers. 在市政大厅里工作，对于一个需要政治前途的人来说，与其说是一块垫脚石，还不如说是一个死胡同。

zausiu’s blog: http://ykyi.net

再介绍一下dead in the water的意思。

英语笔记

Thu, 29 Dec 2011 09:17:49 +0000

# in/out someone’s hair (不)给添乱，烦扰。
She was constantly in my hair, overseeing everything I did.

# Flip-flop 突然改变立场
Bree, could this flip-flop have something to do with the fact that Danielle is dating Mattew?

# Fresh as paint 容光焕发
You have been as fresh as paint over the last six months.
容易与fresh paint(油漆未干混淆)

# put an end to something

# The last straw 最后一根稻草

# Dead meat
If u keep slamming the door like this, u’re dead meat.

Unix网络编程第13章 Daemon Processes and the inetd Superserver 笔记

Mon, 26 Dec 2011 16:59:47 +0000

# The syslogd daemon runs in an infinite loop that calls select, waiting for any one of its three descriptors to be readable. it reads the log message and does what the configuration file says to do with that message. If the daemon receives the SIGHUP signal, it rereads its configuration file. So, what are the three descriptors that the select system call is waiting for ? 1. A unix domain socket is created and bound to the pathname /var/run/log (/dev/log on some systems). 2. A udp socket is created and bound to port 514(the syslog service). 3. The pathname /devklog is opened. Any error messages from within the kernel appears as input on this device. Newer implementation disable the creation of the UDP socket, unless specified by the administrator, as allowing anyone to send UDP datagrams to this port opens the system up to denial-of-service attacks, where some one could fill up the filesystem.

Unix网络编程第十二章 IPv4 and IPv6 Interoperability

Mon, 26 Dec 2011 13:28:35 +0000

# Ethernet header contains a type fileld of 0x0800, which identifies the frame as an IPv4 frame.

# 若支持dual-stack的server既有IPv4又有IPv6。则IP层让server透明地既可处理IPv4又可处理IPv6.该server需要绑定到wildcard且未设置IPV6_V6ONLY socket option.

# UNP Page359 Figure 12.5 Summary of interoperability between IPv4 and IPv6 clients and servers.

# 尽可能用IPv6, since an IPv6 client can still communicate with IPv4 servers, and vice versa.

Unix网络编程第11章 Name and Address Conversions 笔记

Mon, 26 Dec 2011 12:48:53 +0000

# gethostbyname 和 gethostbyaddr 用来在 IPv4 地址和 hostname 之间转换. getservbyport 和 getservbyname 则是与服务相关。gethostbyname出错时不设errno而是设h_errno，并有hstrerror()函数。

# FQDN的全称是: Fully Qualified domain name. 技术上说必须以点号(period)终止.

# AAAA 被称为 “quad A” rcord, 给出了从hostname到Ipv6地址的映射。 PTR用来把IP地址到hostname.

# Entries in the DNS are known as Resource Records(RRs).

# 一个点分十进制(dotted-decimal)IPv4的地址前加 0::ffff:就是 IPv6的字符串形式。

# 与getpeername对应的函数不是gethostname而是getsockname.

# getaddrinfo函数的host参数指定为dotted-decimal IPv4或 IPv6 hex string,会使得只有IPv4或IPv6的addrinfo返回。

# 不给UDP套接字设置SO_REUSEADDR选项。We do not set the SO_REUSEADDR socket option for the UDP socket because this socket option can allow multiple sockets to bind the same UDP port on hosts that support multicasting. Since there is nothing like TCP’s TIME_WAIT state for a UDP socket, there is no need to set this socket option when the server is started.

Prof. Zixiang Xiong讲座脏纸编码

Mon, 26 Dec 2011 11:11:28 +0000

作为主要兴趣在Linux方面的偏应用硕士，听了一个电信传输方面的学术讲座。所谓Dirty Paper Coding，我的理解是如果已知信道干扰，在发射机对发射信号预先减去该干扰，则发射信号经信道传输被接收机接收后，则信道干扰被自动抵消。很简单的Idea，但实际实施起来应该非常困难吧。Prof. Zixiang Xiong先介绍了他所工作的学校。呵。然后从Dirty-paper Coding的历史发展讲起。Instances of dirty paper coding include Costa precoding(1983) ,Tomlinson-Harashima precoding (1971) and the vector perturbation technique of Hochwald et al. (2005)。两位科学家Gelfand和Pinsker开创了这个领域，到信息理论的实际设计准则如何应用到实践之中。Prof. Zixiang Xiong提出了两种有效的编码设计方法。理论回到实路，再介绍这两种编码设计方法在图形图象的数据隐藏，MIMO广播，抗噪预编码，无线网络传输协调方面的实际应用。Gaussian arbitrarily varying channel with a known interference signal at the encoder.

好复杂好深奥的数学变换。本次讲座的收获也就是让我一定程度上开拓了视野，接触到N多电信方面的术语。小波变换，脏纸编码，数字水印之类。术业有专功，我要专功我的Linux去嘞。。。

Sicily 1031 Campus 解题报告.

Mon, 26 Dec 2011 05:12:28 +0000

1 原题中文大意;

Sicily 1031 Campus实际上就是求一个图中给出两点的最短路径的问题。

2 算法思想及解题用到的主要数据结构;

用 dijkstra 算法求给定两点的最短路径.

按路径长度递增次序产生最短路径算法：　　把V分成两组：　　（1）S：已求出最短路径的顶点的集合　　（2）V-S=T：尚未确定最短路径的顶点集合　　将T中顶点按最短路径递增的次序加入到S中，　　保证：（1）从源点V0到S中各顶点的最短路径长度都不大于　　从V0到T中任何顶点的最短路径长度　　（2）每个顶点对应一个距离值　　S中顶点：从V0到此顶点的最短路径长度　　T中顶点：从V0到此顶点的只包括S中顶点作中间　　顶点的最短路径长度　　依据：可以证明V0到T中顶点Vk的最短路径，或是从V0到Vk的　　直接路径的权值；或是从V0经S中顶点到Vk的路径权值之和。

3 逐步求精算法描述

用邻接矩阵存放图.1. 初使时令 S={V0},T={其余顶点}，T中顶点对应的距离值　　若存在，d(V0,Vi)为弧上的权值　　若不存在，d(V0,Vi)为∝ 　　2. 从T中选取一个其距离值为最小的顶点W且不在S中，加入S 　　3. 对T中顶点的距离值进行修改：若加进W作中间顶点，从V0到Vi的　　距离值比不加W的路径要短，则修改此距离值　　重复上述步骤2、3，直到S中包含所有顶点，即S=T为止

3 程序注释清单 // 这份代码通不过sicily。有case错误。我实在找不到原因。

#include <map>
#include <vector>
#include <string>
#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <cassert>
#define INFINITE 0x0FFFFFFF
// 这个类的函数几乎不做参数有效性的检查.
class graph_t

我看过的unix/linux世界的好书

Sat, 24 Dec 2011 12:36:43 +0000

“Advanced Programming in the Unix Environment” Volum I 2nd Edition 大名鼎鼎的 apue 作者是享誉 unix 世界的大牛 Richard Stevens.全书分两卷。第一卷我看了两遍，第二卷翻了翻目录，不想看。

“Linux Device Drivers” 3rd Edition 简称LDD.这本书的中文版翻译的奇烂无比。果断读影印版的，要么就别看了。

“Managing Projects with GNU make” 讲GNU make的书. make这个古老的build工具。怎么说呢。至少我觉得语法设计的非常不友好。无奈的历史问题。

“Version Control with Git” 讲git的书.混了个眼熟。一个人单独做小规模开发用不到那么多特性咯。

<Linux内核设计与实现> 很薄的一本讲linux kernel的书。这本书看的中文版。陈莉君翻译的还不错。只有很少错误。

<Unix编程艺术> 这本书我有中文版和英文版。先买了英文版看看不懂，于是买了中文版看。除非你的英文水平接近有native speaker的水平并且词汇量超大，至少在一万以上吧。否则还是看中文版吧。中文版译得很不错。英文版哥看得非常吃力。5。哥的词汇量接近一万对自己的英文水平看技术类书还是很自信的，但是写这本书的作者是一位极具个性，极具争议的unix hacker，行文风格尽显不羁个性。同样这本书也是争议颇多。支持的奉为圣经，反对的嘲笑作者见识短浅。

“Advanced Bash programming Guide” 讲编写bash脚本的。看的网上的电子版。太多内容了，基本上bash的特性面面惧到。很多内容看了就忘了。

<鸟哥的私房菜基础篇>据说是中文书里算入门的好书了。网上的口啤不错。个人感觉讲的内容非常之浅，不过确实是本入门的好书。但不觉得有收藏价值。这套书还有服务器部分，没有看过。没兴趣也不需要看.

正在看 Richard Stevens 的另一本bible，“Unix network Programming” Volumn I 3 rd Edition。看完了一半。一定要在寒假结束前看完。和apue一样，虽然最新版都是由新的作者在原来的基础上更改的，但仍然保持了Richard Stevens的行文风格用语简练不花哨，详细细致易懂的风格。明年争取啃下 “Understanding Linux Kernel”. 计划选择性看部分"Essential Linux Device Drivers". 顺便提一下Richard Steven写的另一套久负盛名的书Tcp/ip详解，共三卷。简单的过了一下第一卷。没有认真看。

听了林学民教授的一个学术报告

Fri, 23 Dec 2011 15:42:04 +0000

Graph-based Structure Search

林学民教授是数据库理论方面的专家。今天的学术报告，林教授给我们简单介绍了他的研究团队在海量数据检索方面的研究成果。

在快带发展的互联网社会，越来越多的应用需要检索快速地检索基于图结构的海量数据。比如近两三年兴起的，我们非常熟悉的社交网络。对于图的结构化检索是一个NPC问题。海量的数据规模使得问题变得非常的棘手。我搜索了一些资料也没搞清楚什么叫NPC问题。我简单地理解，是当问题的规模变得越来越大时，就不能确定是否能在确定的时间内求出解。

林教授先简单地提到对图的研究方向大致分Mining Graphs,和Quering Graphs。Mining Graphs方面有Frequent Patterns, structure Similarityies, clustering, Ranking, classification。Prof. Lin的团队主要做了Structure Similarities方面的一些研究。对于Querying Graphs，又大致分为Readibility, Connectivity between two nodes, substructure search, shortest paths, strings。Prof. Lin话：对于shortest path，理论上求解很simple，但是应用到大量数据的时候，就要做很多工作。比如要做非常高效的索引。对于strings，一个很长的text可以看成一个长string。比于现在的internet搜索引擎，要解决区分互联网上太多冗余数据的问题，就属于这方面的研究。我知道搜索引擎是鼓励原创的，会给原创的页面比较高的page rank。针对这点，black hat SEO就会搞伪原创，怎样让搜索引擎快速区分出真正的原创内容呢？应该也属于这方面的课题吧。

林教授开始讲他的科研团队的第一个贡献。这个contribution是解决了关于图与图之间包含的问题。问题描述为：给出一个Data Graph和一个Query Graph，要在一个规模非常大的Data Graph里面找到这个Query Graph。林教授介绍了这个过程中的Filtering和Verification算法简要思路。对于不懂学术的我，这部分真是相当地难以理解啊！！！设D是要处理的图。First index a set F of features from D。对于任意f属于F, 求f的超图。索引的算法思路是。如果q是一个frequent subgraph,则 1. 如果q已经被索引，则返回q的超图。2.如果q是一个超图，次q被索引了，不需要给次q的超图做verification。如果q不是一个frequent subgraph的情况下，验证受制于sigmal|D|。林教授认为这个求解过程的主要开销在verification阶段。他们的团队就是把这个cost显著降了一下，而且思路非常地clear和simple。他总结了三条经验： 1. Access infrequent labels as early as possible. 2. Retain connectivity。 3. Effectively use degree information.

The second contribution of Prof. Lin is to put the the theoretic algorithm into practice.有两个问题，一个是query graph被data graph包含(contained)，另一个是query graph包含了data graph.林教授的团队的最结成果比已经发表了论文的另一个科研团队的成果的速度要快了一个数量级。Prof. Lin的语气显得有些遗憾，他们的思路是正确的，实现的效率也很高，但是时间上慢了小小。

http://ykyi.net zausiu's blog

发言队段，研究这个方向的甘同学问了非常专业的问题，我不懂啊！还有一位信科院的研一同学问到了留学的问题，Prof. Lin说他要最top的学生，非常地talented，非常地diligent, 非常地good at algorithm，还要有非常好的practical ability。朝红阳教授向林教授打听有没有做图象search方面的大牛。

学术报告好难啊！我想听工程类的报告。但都是academic report啊！

//////////////////

Topic:

Graph-based Structure Search

Speaker:

Prof. Xuemin Lin

School of Computer Science and Enmgineering,University of New South Wales

and

School of Software ,Eastern China Normal University

Abstract:

Recent years have witnessed an emergence of graph-based applications that strongly demand efficient processing of graph-based queries and searches.

In many real applications such as chem- and bio-informatics, road neworks, social networks, etc., efficiently and effectively conducting structure search on graphs is a key.

The problem of structure search on graphs and its variants are NP-complete. The presence of a large number of graphs makes the problem computationally more intractable.

In this talk, I will introduce recent techniques in graph structure search with the focus on our recent work published in SIGMOD, VLDB, ICDE, etc. My talk will cover the problems of substructure search, superstructure search, and substructure similarity search.

Brief Bio:

林学民，新南威尔士大学大学计算机科学及工程学院教授，数据库研究实验室主任。自2009年4月起，在华东师范大学担任兼职教授，2010年入选国家第四批千人计划学者，2011年6月起受聘于华东师范大学软件学院千人学者。生于上海市，1984年毕业于复旦大学数学系，1992年在昆士兰大学获得博士学位。长期从事数据库理论、算法与技术研究，包括空间数据、不确定数据、流数据、图数据等领域。近年来在数据库领域顶级国际学术会议及顶级杂志上共发表了70余篇学术论文；累计在数据库和算法领域重要的国际学术会议和国际学术期刊发表并录用了170余篇论文，其中10篇国际会议优秀论文，包括ICDE'07上的优秀学生论文奖 (best student paper award) ICDE'10上的优秀论文(one of the best papers) , 及SIGMOD'11 上的优秀论文(one of the best papers)。他目前的研究兴趣是海量数据的处理，包括图数据、时空数据、字符串数据、不确定数据等。学民先后在4th Australasian Theory Symposium (CATS'98), 6th International Computing and Combintorics Conference (COCOON2000), 6th Asia Pacific Web Conference (APweb04), the joint conference of 9th Asia Web Conference and 8th Web-Age Information Management Conference (APweb/WAIM2007), 和 19th and 20th Australasian Database Conference (ADC08, ADC09) 担任会议程序委员会主席，在14th International Conference on Database Systems for Advanced Applications (DASFAA09) 上担任大会主席。目前他是ACM TODS的编委。

Presided by

Prof. Jianlin Feng

Date and Venue

Dec 21, 2011(Wed.) 14：00-15：00

Lecture Theater A101, School of Software, Sun Yat-sen University

冬大过年！无痛终结2011年.展望2012

Thu, 22 Dec 2011 16:56:13 +0000

写在冬至日，总结2011展望2012。冬大过年是广东的俗语。无痛终结是因为人心态早已看得化(开)。

首先：在无比苦逼的11年里，最大的贡献就是返校读书了。基本上确定可以了结本科毕业时被取消学位的心愿。

其次工作上没有什么好说的。在东莞光大集团工作了半年，不能说辛苦也不算闲。工作上没学到什么东东，没明显地进步。在此谢谢赵经理了，如果我有赵经理的硬件水平我就笑哈哈哈哈。以识了几位有意思的同事。

感情上则一如既往地Fail, Fail, Fail 。。。完全木有信心了。哥爱无力了。到了年尾心态竟变得更无所谓，该怎样就怎样吧。只是让家人操心了，对不起啊，尽力了啊。奶奶，对不起啊。也想让你开心的。哎！想起过年回家要去那么多亲戚拜年，555，拜托你们不要问不要问吖。

最后讲讲返校后的生活。在中大的生活第一学期课程非常多，非常忙。我还有我的plan要投入很多时间。时间无论如何不够用！同学关系远没本科时紧密。可能我的心态跟刚毕业的后生仔们相差甚远吧。写到这里，想起今年国庆时去了其它地方没有参加强强和敏的婚礼。唉！什么时候去江苏再给我机会补偿好吗。我做人是越来越失败了，完全是不分好坏敌我的混乱！

2012年是世界的最后一年。可恶的地球人，觉悟吧！

以前每年年尾都会许好多愿望。结果第二年能实现的却渺渺无几。反正都2012了，哥的愿望就务实一点好吧。维护世界和平的任务还是不要勉强啦！

明年必须在寒假结束前看完Unix网络编程.

通过六月的BEC高级考试。

全年选择性的读完Essential Linux Device Drivers和Understanding linux Kernel.

上半年看paper，形成写论文的思路。下半年动手写论文。

下半年拿到offer。银行？民航？其它国企？还是互联网公司抑或其它什么公司？…

感情的事务不设定目标。苦逼的技术宅男果断必然无解！

Unix 网络编程第十章 SCTP Client/Server Example

Mon, 19 Dec 2011 11:25:57 +0000

这一章的内容还是满少的。也就是给出一个SCTP的简单例子。所以也没有太多需要做笔记的。

什么是 head-of-line blocking.

Head-of-line blocking occurs when a TCP segment is lost and a subsequent TCP segment arrives out of order. That subsequent segment is held until the first TCP segment is retransmitted and arrives at the receiver.

怎么更改SCTP连接的stream的数量。

SCTP连接的streams的数量是在association的握手之前协商好的。对于FreeBSD的KAME实现，SCTP的outbound streams默认为10。这个值可以用setsocket函数更改。与SCTP_INITMSG scoket option相关，设置struct sctp_initmsg结构体。

也可以用sendmsg函数发送ancillary数据来到达同样的目标。但发送ancillary data只对one-to-many形式的sctp socket有效。

怎么结束一个SCTP连接。

可以设置sctp_sndrcvinfo结构的sinfo_flags值的MSG_EOF flag来关闭一个sctp连接gracefully. This flag forces an association to shut down after the message being sent is acknowledged.

还可以给sinfo_flags设置 MSG_ABORT。这样就会立即发送一个ABORT给peer端。任何还没来得及发送出的数据会被丢弃。

sicily 2014. Dairy Queen 解题报告

Sat, 17 Dec 2011 12:05:10 +0000

Sun Yat-sen University ACM 2014. Dairy Queen

1. 原题中文大意;

给出一个在 [1, 300] 之间的数字N。然后给出一个集合，这个集合中有C 个数字，C在[1, 8]之间。该集合中的每个数字在[1, 200]之间。问如何用这个集合中的数字组合（数字可以重复使用），使它们的总和等于N。

2. 解这种题毫不犹豫地想到用动态规划。

3. 设一个数组 ways[301]; ways[n]表示有多少种方法可以组合成和n。假设集合中只一个数字x。那么问题就非常简单，只能取n个该数字，和的集合为{x, 2x, 3x}，即ways[x]=1，ways[2x]=1, ways[3x]=1 ….。如果集合中有m数字，假设我们已经求得了用这m个数字的组合可以得到的和的数目存到了ways数组里。即对于m个数字，已求得 ways[1] = ?, ways[2] = ?, ways[3] = ? ….. Ways[300] = ?。那么在此基础上，再加多一个数字，即 m+1个数字的情况会是如何呢。设新加入的这个数字的值是p，则应该是 ways[q] += ways[q-p]。（q > p）

4. 程序注释清单.

#include <string.h>

#include <stdlib.h>

#include <stdio.h>



int main(int argc, char* argv[])

{

int N, C, coin;  // N为题意中的N，C即题意中的C. coin作临时变量用，不解释，可见下面的代码。

int ways[301] = { 0 };  // 见第三部分的分析。

ways[0] = 1;  // 没有实际意义。为了方便计算.



scanf("%d %d", &N, &C);

for ( int i = 0; i < C; i++)

{

scanf("%d", &coin);

for ( int j = coin; j <= N; j++ )

{

ways[j] += ways[j-coin];  // 见第3部分的分析.

}

}

printf("%d\n", ways[N]);



return 0;

}

5.时间复杂度，空间复杂度分析。

空间复杂度是确定的常数。时间复杂度是o(n). n为有多少种面值的硬币。

http://ykyi.net zausiu's blog

原题：

Description

Bessie, always in need of an income, has decided to leverage her dairy skills by taking a part-time job at the local Dairy Queen restaurant. She is running a special cash register (since she has hooves instead of fingers and thus requires special accommodation). Her job is making change for customers as they make a purchase.

As she was counting out 83 cents in change, she wondered: "How many ways can I count out 83 cents? I can use three quarters and eight pennies, seven dimes and three pennies, 83 pennies… there must be a zillion ways!"

How many different ways can one make change for N (1 ≤ N ≤ 300) cents using coins from a set of C (1 ≤ C ≤ 8) coins of supplied values C_i (1 ≤ C_i ≤ 200)? "Different" means differing counts of coins.

Thus, 8 cents can be made, in American currency, with 1 five-cent piece + 3 one-cent pieces and also with 8 one-cent pieces. Using 3 one-cent pieces + 1 five-cent piece is the same as 1 five-cent piece + 3 one-cent pieces, so one can create eight cents in just two different ways. Note that some coin systems are poor at making change and result in an answer of '0'.

Coin values in the input file are listed in descending order from largest to smallest. All coin values will be distinct.

Input

Line 1: Two space-separated integers: N and C
Lines 2..C+1: Line i+1 contains a single integer: C_i

Output

Line 1: A single line with a single integer that is the number of ways to create N cents of change using the supplied coins. The answer is guaranteed to fit into a signed 32-bit int

Sample Input

Sample Output

Unix网络编程.第九章笔记

Sat, 17 Dec 2011 08:58:14 +0000

# TCP 协议在1981年标准化，而SCTP协议则是在2000年由IETF组织标准化。IETF： Internet Engineering Task Force 互联网工程任务组成立于1985年。

# SCTP支持两种类型的socket. one to one(为了方便现有的tcp程序迁移到sctp) 和 one to many.

# sctp的sctp_bindx可以绑定多个地址，并且可以动态增删。但动态增删不影响已经存在的associations.不过各个unix分支不一定支持这个特性。

# sctp_getpaddrs和sctp_getladdrs分别是getpeername和gethostname的sctp版。They are designed with the concept of a multihoming aware transport protocol.

# sctp传输的报文是有边界的。sctp在传输层支持传输超大的message.

Is your biometric data safe

Fri, 16 Dec 2011 16:31:09 +0000

Kot教授的这个讲座在网页上写的标题是：IEEE Distinguished Lecture Talk。多么气质不凡的Distinguished啊！！！作为一个小工程硕，实在有受宠若惊之感。

讲座的大概讲的Kot教授提出了如何构建一个新颖的(novel)系统来保证Biometric信息在服务端的安全。即使这部分信息泄露出去，攻击者也不能够利用它。首先什么是BIOMETRIC呢？你的指纹，你的面部，你的头发…都属于Biometric。其实Biometric对于大家都不会陌生，指纹考勤系统实在是相当之普遍啊。而且科幻或者犯罪电影里还有虹膜校验。

Kot教授提出Biometric的验证系统的不安全的方面，如果被泄露出去，Biometric信息不像普通密码一样容易被更换，一但被伪造这样就会比传统的验证方法更加麻烦。Prof. Kot简单地walk through了几个保护Biometric的解决方案，并说明Biometric信息是可以被利用被伪造的。

PPT中多次提到Minutiae的概念，一直没听明白啊！貌似是从原始的Biometric信息中提取出部分信息而作为用来验证的数据。Professor Kot论证常见的基于指纹的验证系统的弊端。论证中非常多的“valley”，"ridge"，比较变换前后的差异。不明白啊，不明白！大概的结论是目前的技术可以做到从Minutiae中reconstruct到原始的original fingerprint。后来想这时候论证的是为了支撑其后Prof. Kot提出的新的novel solution.

Kot提出的解决方案是在采集指纹信息时需要采集用户的两个不同的手指，然后综合这两个手指的信息计算出一个Minutiae。这个Minutiae与从采集单个手指得到的Minutiae几乎没有差别。因为这个Minutiae记载的是两个不同手指的信息，而且每个手指仅仅只记部分信息。这样的话，即使攻击者盗取了这个Minutiae，它就无法原始到原始的fingerprint。按我自己的理解，攻击者应该也不清楚它还原得到的指纹其实并不存在，因为Minutiae是两个指纹的信息合成的而且与由单个指纹得到的几乎一样，攻击者无法分辨。攻击者应该会沾沾自喜reconstruct到了被误导的original finger print。

Kot还指出在他提出的这个解决方案中可以嵌入信息记到Minutiae里面。在后面的提问阶段。有同学问到这个解决方案可以存入多少信息。Kot补充目前可以存一千多个Bit位信息，足够存下重要的身份认证数据了。按我自已的理解，能存多少信息应该是可以根据需要调大和缩小的呀。比如把图形转成矢量图形后，就可以不失真的放大，于是就会有更多存储空间了。不确定是不是这样。

提问阶段Kot指出这个设计没有使用token或者key因此会运行的非常迅速。而如果采用复杂的加解密算法，则会有非常大的计算开销。运行速度对于一些嵌入式的电子系统是至关重要的。

有同学提问提到做Face Recognition，问Kot教授有什么看法。Kot认为Face Recognition is very difficult, very very difficult, few advancement has been achieved nowadays. It's a very tough problem.

At last, as a conclusion for this report, I must show my great respect to Alex Kot. He is a great scientist.

/////////////////

IEEE Distinguished Lecture Talk

Title：Is your biometric data safe?

Speaker：Prof. Alex C Kot, 新加坡南洋理工大学教授、IEEE Fellow

时间： 12月16日（本周五）下午3：00

地点： 信息科技学院大楼二楼207讲学厅

主持人： 黄继武 教授

主办单位：信息科学与技术学院、IEEE Signal Processing Society Guangzhou Chapter, IEEE Circuits and Systems Society Guangzhou Chapter

Abstract

Nowadays, biometrics is widely used in authentication systems. In general, biometrics needs to be stored in a database for subsequent authentication. However, templates stored in the database are at the risk of being stolen or modified. Once the template is stolen, it is difficult to be replaced like passwords and the private user information associated with the stolen template would also be exposed. Thus, biometrics templates should be stored in the database such that both the security of the template and the privacy of the user are not compromised under various attacks.

We first propose a fingerprint authentication system for the privacy protection of the fingerprint template stored in a database. The considered fingerprint data is a binary thinned fingerprint image, which will be embedded with some private user information without causing obvious abnormality in the enrollment phase. In the authentication phase, these hidden user data can be extracted from the stored template for verifying the authenticity of the person who provides the query fingerprint. A novel data hiding scheme is proposed for the thinned fingerprint template. Compared with using existing binary image data hiding techniques, the proposed method causes the least abnormality for a thinned fingerprint without compromising the performance of the fingerprint identification.

The minutiae is another type of data stored in a fingerprint template. We investigate to what extreme a reconstructed fingerprint can be similar to the original fingerprint. A new scheme is proposed to reconstruct a full fingerprint image from the minutiae points. Experimental results show that the successful match rate between our reconstructed fingerprint and the original fingerprint is over 99% at FAR=10^-4. When matched against the different impressions of the original fingerprint, our reconstructed fingerprint has over 86% successful match rate at FAR=10^-4. We consider the privacy issues of the fingerprint reconstruction. The analysis shows that our proposed technique is useful for protecting the fingerprint ridge frequency.

As a reconstructed fingerprint can be so similar to the original fingerprint, it is also very important to protect the privacy of the minutiae template stored in a database. We propose a novel system for protecting the privacy of the fingerprint minutiae without using a token or key. In the enrollment, two fingerprints are captured from two different fingers of the same person. A combined minutiae template containing only a partial minutiae feature of each of the two fingerprints will be generated and stored in a database. In the authentication, the user needs to provide two query fingerprints from the same two fingers which are used in the enrollment. By storing the combined minutiae template, the complete minutiae feature of a single fingerprint will not be compromised when the database is stolen. Furthermore, because of the similarity in topology, it is also difficult for the attacker to distinguish our template from the minutiae of an original fingerprint. The experimental results show that our system can achieve a very low error rate.

Biography

Dr Kot has been with the Nanyang Technological University, Singapore since 1991. He headed the Division of Information Engineering at the School of Electrical and Electronic Engineering for eight years until 2005. The Division’s research focuses are on signal processing for image, video, speech and audio. He started serving as Vice-Dean (Research) for the School of EEE in 2005 and became Associate Dean for the College of Engineering in 2008. He is currently a Professor at the School of EEE and Associate Dean for the College of Engineering. He has published extensively with over 200 technical papers and 3 patents in the areas of signal processing for communication, biometrics recognition, data-hiding, authentication and media forensics.

Dr. Kot served as Associate Editor for the IEEE Trans. on Signal Processing, IEEE Trans. on Multimedia, IEEE Trans. on Circuits and Systems for Video Technology; and IEEE Trans. on Circuits and Systems Part II as well as Part I. He also served as Guest Editor for the Special Issues for the IEEE Trans/ on CSVT and JASP. He is currently Associate Editor for the IEEE Trans. on Information, Forensics and Security, IEEE Trans. on Image Processing and IEEE Signal Processing Letter. He is also Editor for the EURASIP Journal of Advanced Signal Processing, the IEEE Signal Processing Magazine and the IEEE Journal of the Special Topics in Signal Processing. He is an Editorial Board member of the Journal of Fundamental and Theory in Signal Processing. He serves in the IEEE CAS Visual Signal Processing and Communication, the IEEE SPS Image and Video Multi-dimensional Signal Processing and IEEE SPS Information Forensic and Security technical committees. He has served the IEEE Society in various capacities such as the General Co-Chair for the 2004 IEEE International Conference on Image Processing (ICIP) and Chair of the worldwide SPS Chapter Chairs and the Distinguished Lecturer program. He serves as IEEE Fellow Evaluation Committee. He received the Best Teacher of the Year Award and is a co-author for several Best Paper Awards including ICPR, WIFS and IWDW. He was the IEEE Distinguished Lecturer in 2005 and 2006 and is a Fellow of IEEE and IES.

Distributed Framework for Iterative Computations on Massive Datasets

Fri, 16 Dec 2011 16:14:26 +0000

I must confess I've only got a few words and a vague skeleton of what the Professer Lixin Gao said due to the language barrier, during the whole speech Ms Gao spoke English, and the topic is so pedantic which is full of the complicated mathematic formulation.Personally，我未有涉及过海量数据并行计算以至云计算相关的任何技术，基本上对于海量数据的所有技术都让我觉得非常地cutting-edge。带着学习开拓眼界拓展知识面的良好愿望参加了Ms. Gao的学术讲座。Ms. Gao讲PPT时全是英文啊。我努力地听，努力地听！！！适当地记些笔记。其实还是很喜欢听英语的。

讲座先列举了一些大型互联网公司的数据显示集群计算的规模。比如谷歌在数据中心有一百万台服务器！！！Holy gosh，1,000,000 servers！！！

然后谈到了很多大规模数据的计算对时间的要求非常地严格。于是谈到了目前流行的算法：MapReduce。MapReduce是google提倡的一种编程模型，用于大规模数据集（大于1TB）的并行运算。“Map”和 “Reduce”，和他们的主要思想，都是从函数式编程语言里继承来的，还有从矢量编程语言里借来的特性。他极大地方便了编程人员在不会分布式并行编程的情况下，将自己的程序运行在分布式系统上。我自己的理解是：map索引整个海量数据，生成key-value pair which is used to facilitate the quick query and computing。而reduce则是用来分析和统筹基于键值对的中间计算结果，使中间结果迅速向最终的正确结果收敛。

Ms. Gao 提出MapReduce虽然是工业界非常popular的解决方案，但是不可以以迭代的方式计算。而Ms. Gao所做的工作即是使MapReduce支持迭代的功能。（A framework that support iterative computing in the cloud.）从事情一般规律的哲学高度看待这个问题，对于规模相当大或者最终结果是相当不明确的问题，似乎都可以用到'迭代'的思想。例如，迭代的软件开发模式则是当今互联网应用的主要开发模式。每一次迭代都使产品向理想中最perfect的状态接近。Ms. Gao用迭代的思想处理海量数据应该也是同样的道理罢！

Ms. Gao的解释说改进后支持迭代的iMapReduce可以使map后的数据支撑reduce,reduce的数据亦转而支撑map，形成一个迭代反复的过程，其中在map阶段加入static data。较之原始的MapReduce，新的算法使得static data的规模显著地减少。Ms. Gao展示了几个图表证明改进后增加了迭代功能的MapReduce(称之为 iMapReduce )的速度优于原始的MapReduce.图表中有展示用iMapReduce计算PageRank的值。PageRank？是不是判断网站权重的那个东东啊？哥的网站http://ykyi.net的PageRank才啊！！！才啊~~用什么算法可以算成9啊！

PPT转到计算图的指定两点最短路径的Dijkstra算法。泪流满面，终于有一个我懂的算法了啊！Ms. Gao说先找到两个结点间的最短路径，于是赋于这个最短路径经过的结点最高的权重，其它的路径就赋于相对低的权重。提出了PriorityQueue的数据结构。把权重引入到iMapReduce算法，称之为pMapReduce算法。引入权重后的pMapReduce算法比iMapReduce算法的速度更快。生活中我们做事情也要优先处理最重要的事情，道理是一样的啊！世间万事万物，无论多么复杂，抽象出来的一般规律其实都是相当地一致。易经中说：形而下者谓之器，形而上者谓之道！Oops, The ancient Tao philosophy is full Of Wisdom.

最后阶段，再次展示了一个图表，Ms. Gao完成的建立在Apache的Hadoop上的pMapReduce要明显的优于原始的Hadoop。并且也优先其它多种解决方案，其它的名字我都没听过啊！在提问阶段，尽管温武少老师积极鼓励同学提问但没有同学提出问题，大概大家都不懂吧！朝红阳老师和另一位研究海量数据的老师谈了一点点。他们提到iterative的算法在他们的实际应用中效果并不是太明显，不如memory-based的解决方案。Ms. Gao调出一张图表，解释说某种memory-based的解决方案没有迭代的算法快。

作为众多打酱油的同学中的一员，我最后的心得体会是：学术真是太高深了啊！我还是做工程吧！！！车，我有得拣咩？

/////////////////////////

Topic

Distributed Framework for Iterative Computations on Massive Datasets

Speaker

Prof. Lixin Gao

Abstract

Iterative algorithms are pervasive in many applications such as search engine algorithms,machine learning, and recommendation systems. These applications typically involve a dataset of massive scale. Fast iterative computations of the massive datasets are essential for these applications. This is particular important for on-line query such as keyword based search query. In this talk, we present an overview of MapReduce framework, and propose two frameworks, iMapReduce and pMapReduce, that enable fast iterative computations. By providing the support of iterative computations and prioritized execution, we can ensure faster convergence of the iterative process. Both iMapReduce and pMapReduce preserve the MapReduce distributed computing framework and is particularly efficient for online queries such as top-k queries. We implement iMapReduce and pMapReduce based on Apache Hadoop and evaluate its performance. Our evaluation results show that pMapReduce can reduce the computation time by two orders of magnitude comparing to that achieved with MapReduce. At the end of the talk, I will provide an overview of on-going projects in my research group.

Bio

Lixin Gao is a professor of Electrical and Computer Engineering at the University of Massachusetts at Amherst. She received her Ph.D. degree in computer science from the University of Massachusetts at Amherst in 1996. Her research interests include social networks, and Internet routing, network virtualization and cloud computing. Between May 1999 and January 2000, she was a visiting researcher at AT&T Research Labs and DIMACS. She was an Alfred P. Sloan Fellow between 2003-2005 and received an NSF CAREER Award in 1999. She won the best paper award from IEEE INFOCOM 2010 and her paper in ACM Cloud Computing 2011 was honored with “Paper of Distinction”. She received the Chancellor’s Award for Outstanding Accomplishment in Research and Creative Activity in 2010, and is a fellow of IEEE.

<p>
  &nbsp;
</p>

<div>
  <strong>Date and Venue</strong>
</div>

<div>
  Dec.16（Friday）13:30pm-14:30pm
</div>

<div>
  Lecture Theater A101, School of Software, Sun Yat-sen University
</div></p>

Unix网络编程.第七章笔记

Thu, 15 Dec 2011 06:33:56 +0000

1. 有一个 Generic Socket Option：SO_BROADCAST 用来开启是否充许广播。2. 仅有TCP支持SO_DEBUG。Kernel把详细的发送包的接收包信息存在一个环路buffer里。可以用trpt查看它。3. SO_ERROR套接字选项只能被取得，不能被设置。如果进程阻塞在select调用里，不论是读还是写，select都会返回conditions set。如果进程使用signal-driven I/O，则SIGIO信号会被发到这个进程或者它所在的进程组。进程用getsockopt得到so_error后，so_error就会被重置为0.如果so_error不为，此时调用 read 或者 write 就会立即返回-1，errno被置为so_error的值。

4. SO_KEEPALIVE在一个tcp连接没有任何收发达两个小时时会发一个prob给对方。两个钟喔。好长的时间啊！！！Richard Stevens认为SO_KEEPALIVE应该改叫 make-dead。大多Unix的kernel把这个两小时时长存为一个系统级的变量。这意味着如果你用某种方法改变了这个时长，会影响这个操作系统的所有socket.Richard Stevens认为想把这个时长改短的想法是错误理解了这个选项的意义。

5. SO_LINGER仅仅适用于面向连接的socket，比如TCP和SCTP，因此不适用UDP。

Struct linger{

int l_onofff;

int l_linger;

};

L_onoff为零是，close的behavior就是默认情况：close立即返回，kernel继续发送缓冲区内未发送的数据。当l_onoff不为零，而l_linger为，TCP协议则会立即终止连接，发送RST给peer端，这样做避免了TCP的TIME_WAIT状态，这样的坏处是: leaves open the possibility of another incarnation of this connection being created within 2MSL seconds and having old duplicate segments from the just-terminated connection being incorrectly delivered to the new incarnation.对于SCTP, 也会发送一个ABORT chunk给peer.第三种情况：如果l_onoff为真，l_linger不为0.则close不会立即返回，会最多等待指定的时长，在这段时间里kernel发送缓冲区内的数据给peer。如果在这段时间内发送完则close返回0.如果没有发送完毕，close就会返回EWOULDBLOCK，send buffer里的数据会被丢弃。

6. MSL: maximum segment lifetime.

7. 因此close默认情况下立即返回，即使用SO_LINGER设置等待时间也在理论上存在close先于发送缓冲区的数据被peer端acknowleded的情况。因此一个更好的解决方案是用shutdown系统调用with a second argument of SHUT_WR。在调用shutdown后，用read调用直到read返回，即收到peer端的FIN。

8. UDP没有congestion control，如果发得太快，不仅仅peer端来不及收。A fast sender can overwhelm its own network interface, causing datagrams to be discarded by the sender itself.

9. 因为tcp在三次握手阶段的SYN segment里交换窗口大小(windows scale)。所以tcp的接收缓冲大小必须在shank hands之前就设置好。Connected socket从listening socket继承这个选项。

10. TCP的套接字缓冲区大小至少需要是4倍MSS的大小。这里指的套接字缓冲，如果是针对单向的传输，比如单向传一个文件，指的是发送方的发送缓冲和接收方的接收缓冲。如果是双向的传输，则指的是双方的接收和发送缓冲。为什么tcp套接字的缓冲区需要至少是4倍MSS的大小呢？这是因为tcp的快恢复(fast recovery)算法。快恢复算法定义：如果接收端连续收到三个同样的ACK，就认为有packet丢失了。而接收端在segment丢失后，每收到新的segment就不停地重发一个重复的ack给sender。如果窗口大小小于4个segments,就不会有三个重复的ACK,所以快恢复算法就没办法工作了。

11. What is bandwidth-delay product.

A: The capacity of the pipe is called the bandwidth-delay product and we calculate this by multiplying the bandwidth(in bits/sec) times the RTT(in seconds), converting the result from bits to bytes. 即网速乘上RTT.

12. UDP没有send buffer，但有一个send buffer size.只要socket的buffer size大于LO_WATER，就永远是可写的。

13. SO_REUSEADDR有四种用途。好难写。见Unix Network Programming Section 7.5 影印版第211页啦。

14. It's Ok for the MSS to be different in each direction.

15. Nagle算法是为了减少small package的数量.The algorithm states that if a given connection has outstanding data, then no small packets will be sent on the connection in response to a user write operation until the existing data is acknowledged. Small package 指的是任何比MSS小的package.

16. Delayed ACK algorithm: This algorithm causes TCP to not send an ACK immediately when it receives data; instead, TCP will wait some small amount of time (typically 50-200ms)and only then send the ACK.

17. SCTP有一个SCTP_AUTOCLOSE套接字选项。This option allows us to fetch or set the autoclose time for an SCTP endpoint. The autoclose time is the number of seconds an SCTP association will remain open when idle.即SCTP association能够保持空闲状态的最长时间。超时就会被关闭。

人类中心主义未必导致环境的破坏.自然辩证法作业

Thu, 15 Dec 2011 02:46:01 +0000

人类中心主义是一种价值尺度。它主张把人类的利益作为价值原点和道德评价的依据，有且只有人类才是价值判断的主体。作为这个星球上唯一具备高级的情感，复杂的逻辑思维，有复杂的语言系统等等一般生物所不具备的特征的生物。人类明显区别于其它生物种类。人类要生存与发展，不断实现人类价值的提升突破，当然要利用我们生存的环境中的其它生物和自然物。

有一种观点认为：人类中心主义将会导致环境的破坏。这种观点实际上并没有真正理解什么是人类中心主义。人类中心主义最重要最核心的一点，它把是否符合人类的利益作为是非评价的标准。按照这样的价值尺度，又依据破坏环境的行为将最终损坏人类的利益，那么，破坏坏境的行为显然就不是人类中心主义所主张的！恰恰相反，人类中心主义为了维护人类的利益，就要毫不含糊地，旗帜鲜明地支持保护环境。

那么为什么会有那么多人把人类中心主义与环境保护对立起来呢？我想，是因为这些人并未真正理解人类中心主义的中心思想。一个重要的原因是一部分人想当然的把人类中心与环境保护对立起来。另一个重要的原因还在于很多伪人类中心主义者为了短期的眼前利益，为了一时一刻一朝一夕的短期发展，不惜牺牲环境。伪人类中心主义者也自称是人类中心主义者，实际上他们的所作所为与真正的人类中心主义者背道而驰。这些自我标榜的人类中心主义者并不是少数，他们在社会上为人类主心主义造成了相当的负面影响，于是影响了公众对人类中心主义的看法。

作为结论，为了从根本上长远地使我们生活的环境有符合人类的利益，有利于人类的生存与发展。我们在判断一件事是否符合人类中心主义的价值尺度时，不能仅仅着眼于眼前和局部利益，而是要站在更高更远的位置着眼于大局，着眼于长期发展。这样，就能同伪人类中心主义者划清界限。

就人类中心主义的现实意义来讲。我国在过去半个多世纪的发展，尤其是近三十年来的发展只是片面的追求短期的GDP指标，忽略了对环境的保护。这样的粗放型发展模式已经难以为继。在目前的中国社会中，因为忽视环境保护而造成的负面影响已经越来越明显，越来越频繁的表现出来。如频繁的自然灾害，如最近媒体集中关注的北京空气质量问题。这样的发展模式最终损害了人类的利益，实际上是不符人类中心主义主张的。
http://ykyi.net zausiu’s blog

新千年伊始胡温政府提出的科学发展观就是为了解决上文提到的偏差。其实际效果却不能说”成效显著”。对于如此宠大的一个十亿人口的大国，环境问题极端重要，每个人都必须意识到掠夺式地破坏坏境最终会损害社会大众的共同利益，也会损害自已的利益。

中大sicily 1426. Phone List 解题报告

Sun, 11 Dec 2011 15:50:04 +0000

1.原题中文大意;

给出一组数字，最多一万个，判断这组数字中是否存在一个数字是其它一个数字的前缀。

2.算法思想及解题用到的主要数据结构;

每读入一个数字字符串，则把该数字串从高位到低位分解成一个个数字字符。然后开始以最高位数字为树的根，第二个数字为根的子孙结点，第三个数字为第二个数字的子孙结点。如果碰到最后一个数字，如果这组数字符合要求的话则最后一个数字字符一定是叶子结点。不断的加入新的数字字符串到树中，如果在加入的过程中使以前的叶子结点变成了非叶子结点，或者新加入的数字字符串的最后一个数字在树中不是一个叶子结点，则报告这组数字字符串不符合要求。反之，则符合要求。

3.逐步求精算法描述（含过程及变量说明）;

每个结点记下关键信息,一个数字字符。再加上一个指向其它信息的指针. 这个指针指向一个node_data_t结构。结构体中放置了一个tag标签，记字是不是一个数字字符串的最后一个数字；以及一个指向STL的set容器，容器中放置了所有子孙结点。如下代码描述。

struct node_t

{

char _ch;

node_data_t* _data;

};

struct node_data_t

{

set _nodes;

bool _terminal;

};

剩下的逻辑便是分析数字字符串，把每个字符拆出加入树中。

4.程序注释清单

#include <set>
#include <algorithm>
#include <cstring>
#include <cstdlib>
#include <cstdio>
using namespace std;
struct node_comp;
struct node_data_t;
struct node_t
{
char _ch;
node_data_t* _data;
};
struct node_comp  // 给STL的set容器的排序算子。
{
bool operator()(const node_t& left, const node_t& right)const
{
return left._ch < right._ch;
}
};
http://ykyi.net zausiu's blog
struct node_data_t
{
set<node_t, node_comp>  _nodes;
bool _terminal;  // 标记是不是一个电话号码的终点字符了。
};
typedef set<node_t, node_comp> nodes_set;
nodes_set top_nodes;
// 如果已经可以判断电话号码不满足要求就返回false.
// 递归调用该函数。
bool odyssey(nodes_set& nodes, const char* num)
{
if ( 0 == *num )
{
return true;
}
//
node_t node;
node._ch = *num;
node._data = new node_data_t;
node._data->_terminal = !num[1];
pair<nodes_set::iterator, bool> retval = nodes.insert(node);
if ( retval.second )  // 还没有这个数字的结点.新插入的.
{
bool b;
b = odyssey(retval.first->_data->_nodes, num+1);
return b;
}
else  // 已经存在
{
delete node._data;
// 并且已经是之前一个数字串的最后一个数字字符.或者现在这个字符是最后一个.
if ( retval.first->_data->_terminal || !num[1] )
{
return false;
}
else if ( !num[1] )
{
retval.first->_data->_terminal = true;
return true;
}
else
{
retval.first->_data->_terminal = false;
bool b;
b = odyssey(retval.first->_data->_nodes, num+1); // 递归
return b;
}
}
}
// 释放内存.
void free_mem(nodes_set& nodes)
{
for ( nodes_set::const_iterator ite = nodes.begin();
ite != nodes.end();
++ite )
{
free_mem(ite->_data->_nodes);
delete ite->_data;
}
nodes.clear();
}
int main(int argc, char* argv[])
{
int case_count;   // 有多少个case
int phone_num_count;    // 多少个电话霖巴
char phone_num_str[11];   // 存电话霖巴
bool successed;  // 一组数字字符串是否符合要求
scanf("%d", &case_count);
for ( int i = 0; i < case_count; i++ )
{
scanf("%d", &phone_num_count);
successed = true;
for ( int j = 0; j < phone_num_count; j++ )
{
scanf("%s", phone_num_str);
if ( successed )
{
successed = odyssey(top_nodes, phone_num_str);
}
}
if ( successed )
{
printf(“YES\n”);
}
else
{
printf(“NO\n”);
}
free_mem(top_nodes);
}
return 0;
}

5.测试数据

用简单的脚本帮助生成测试数据.

#!/bin/bash

INDEX=0

if [ -e $1 ];then

COUNT=200

else

COUNT=$1

while [ $INDEX -lt $COUNT ];do

let "INDEX=$INDEX+1"

echo $RANDOM

done

6.对时间复杂度，空间复杂度方面的分析.

本算法的时间复杂度的空间复杂度一般都介于O(logN)和O(N)之间。

//////////////// 原题 //////////////

1426. Phone List

Description

Given a list of phone numbers, determine if it is consistent in the sense that no number is the pre?x of another. Let’s say the phone catalogue listed these numbers:

? Emergency 911

? Alice 97 625 999

? Bob 91 12 54 26

In this case, it’s not possible to call Bob, because the central would direct your call to the emergency line as soon as you had dialled the ?rst three digits of Bob’s phone number. So this list would not be consistent.

Input

The ?rst line of input gives a single integer, 1 ≤ t ≤ 40, the number of test cases. Each test case starts with n, the number of phone numbers, on a separate line, 1 ≤ n ≤ 10000. Then follows n lines with one unique phone number on each line. A phone number is a sequence of at most ten digits.

Output

For each test case, output “YES” if the list is consistent, or “NO” otherwise.

Sample Input

911

97625999

91125426

113

12340

123440

12345

98346

Sample Output

YES

Unix网络编程.第五，六章笔记.

Sat, 10 Dec 2011 13:56:00 +0000

# Unix世界里经常看到的 pst 是 pseudo terminal 的意思啊。

# ps -t pts/6 -o pid,ppid,tty,stat,args,wchan

ps 命令的进程状态。 S表示进程在睡眠，I表示进程在等待输入，O表示进程在等待输出。当进程在S状态时，wlan指示了更详细的状态信息。

# SIGSTOP 和 SIGKILL 两个posix信号不可以被caught.

# 缺省情况下，Unix的信号是不排在队列中的。这意味着多个相同signal到达的时候如果没有来得及处理，就只会记下一个signal.如果需要稳定的信号支持，就要使用RealTime Posix接口。

# init 进程的PID是 1.

# 可以用sigprocmask函数block和unblock信号。This let us protect a critical region of code by preventing certain signals from being caught while that region of code is executing.

# 对于 Unix System V 和 Unix98, the child of a process does not become a zombie if the process sets the disposition of SIGCHLD to SIG_IGN. unfortunately, tis works only under System V & Unix98. Posix明确指票这个行为是未定义的。The portable way to handle zombies is to catch SIGCHILD & call wait or waitpid.

使用Necessitas在Android平台上运行Qt程序失败

Fri, 09 Dec 2011 12:31:21 +0000

什么是 Necessitas?

Necessitas是Qt在Android操作系统上的一个移植，同时提供了Qt Creator与Android的集成。Necessitas计划为你提供了Android平台下的Qt,以及一个一流的平易近人的IDE，方便你在安卓平台下管理，开发，部署，运行 & 调试你的Qt应用。

什么是Minstro?

Necessitas也是Ministro的官网。Ministro为LGPL Qt共享库提供了一个系统范围的下载器(downloader)和安装器(installer)。你可以在Andorid软体市场获得Ministro。

如何安装Necessitas SDK开发包?

相当地easy啊！http://sourceforge.net/projects/necessitas/files/ 下载sdk开发包。有linux, win, mac 三个平台下的。安装过程傻瓜式 next next next 。哥尝试在Linux下安装出错了。安装程序没有加载起来。

zausiu@potassium:/tmp$ ./necessitas-0.3-online-sdk-installer-linux

./necessitas-0.3-online-sdk-installer-linux: error while loading shared libraries: libgobject-2.0.so.0: cannot open shared object file: No such file or directory

我先尝试在deibian安装linux版本。结果安装文件启动时加载libglobject.so失败了！但是明明在/lib目录下啊！解决不了，唔知点解！就只好在win7下安装了windows版本。注意要勾选上装 ant，如果你的系统里之前没有安装ant的话。装好ant后还要把ant的路径添加入环境变量里。

如何安装Android SDK开发包？

去官网下载了然后安装。简单地令人发指！！！哥不能讲怎么安装它，免得说我侮辱你的智慧。

http://developer.android.com/sdk/index.html

开始开发

运行在安卓上的Qt程序被编译成共享对象(shared objects)。一个Java Launcher，已经集成在necessitas sdk里，会加载这个shared objects。当然，对于应用开发者，这个Java Launcher是完全透明的。要注意的是，Qt包含了很多互相引用的库，只有Android V1.6以上才支持这个functionality。

哈。最最重要的。尝试第一个将被部署到android上的Qt应用。用安装好的 Necessitas Qt Creator创建了一个GUI程序。运行。。。运行。报错了！！！哭啊。

ma-make: *** [install_target] Error 2

The process "D:\necessitas\QtCreator\bin\ma-make.exe" exited with code 2.

Error while building project 4android (target: Android)

When executing build step 'Copy application data'

用"When executing build step 'Copy application data'"google了一下。木有得到有价值的信息。不知道如何解决啊。哈~~那就不管了！！！

linux的soname，链接库的问题.

Thu, 08 Dec 2011 09:36:54 +0000

第一次看到soname是读<程序员的自我修养.第一册:链接库>看来的。顺便说一下，这本书确实是本好书吖，国内出的难得技术好书。后来在公司的项目中把它从windows平台下移植到linux下，写makefile时用到过。

再后来又忘记了。今天再次看到soname的时候就有点记不起来了。又只好搜索了一些资料看。趁热打铁把学会的东西记下来。

linux为尝试解决动态链接库版本冲突的问题(windows平台下称之为DLL HELL)，引入了soname进制。linux的动态链接库的扩展名约定为.so 即shared object的缩写。下面的makefile语句来自于哥今年上半年写的makefile文件:

VERSION_NUM := 1.0.0
soname = lib$(dirname).so.$(firstword $(subst ., ,$(VERSION_NUM)))
LINKFLAGS := -shared -Wl,-soname,$(soname) -L. -lpthread -lrt -lpentagon -lcross_platform
其中的变量$(soname)会被替换为eibcomm.so.1。再看看LINKFLAGS变量指定的几个选项. -shared 表示要生成一个shared object，即动态共享库. -pthread -lrt -lpentagon -lcross_platform 是要链接其它几个库，thread和linux的posix线程库,rt是一个和实时系统相关的库它提供了高精度的时间函数。

比较奇怪的是 -Wl,-soname,$(soname) 它们之前用逗号分开，而不是用空格分开。实际上这几个东东会被gcc传给ld(linux下的链接器)作为链接器的参数。gcc规定的写法就是这样的。指定的soname会被链接器写入到最终生成的elf文件中(linux下的可执行文件格式)。要查看elf文件的段布局什么的，可以用readelf工具。

最终生成的文件将命名为 libname.so.x.y.z 的形式。soname是libname.so.x的格式(也不尽然，这只是一个convetion,并非在语法或机制上强行要求)。接着把生成的so文件拷贝到/usr/lib 或者 /lib，这两个文件夹是系统用来放置动态链接库的地方。debian下没有把/usr/local/lib作为默认的动态链接库文件夹.可以通过改/etc/ld.so.conf 文件把更多的路径加入。再运行 ldconfig,更新cache中的库文件信息。为什么要用cache呢，有人就问了！因为library实在太多了咯，cache就被引用了。cache是个好东西啊！！！

这个时候依赖 libname.so.x 的文件就可以找到这个library并加载起来了。但是编译程序时还是找不到呢.编译程序时通常会写 -lname 这个时候会先找 libname.so 再找 libname.a 文件，结果找不到。link就会抱怨没有找到这个库文件。为了让编译通过，于是你就用 ln -sf libname.so libname.so.x.y.z (这个是realname,版本号部分可能只有x.y两个部分) 建一个软链接！搞定！

关于听陈光荣教授《混沌的故事》讲座的心得报告

Tue, 06 Dec 2011 14:15:29 +0000

在听你陈老师(陈光荣教授，见文章未尾的介绍)的报告之前没有听说过“混沌数学”的概念。阅读了网络上的一些资料以后，有了大致的认识。早在初中生的年代，有在数学科普杂志上看到过“模糊数学”的概念。我想，“混沌数学“应该就是“模糊数学“近乎罢。

陈老师的讲座重点在浅显介绍“混沌数学“，并没有涉及太多混沌理论的学术内容。报告从牛顿时期的三大定律讲起，当时的的科学界普高认为世界是一个确定的机械系统。到科学家彭家莱在研究天体运动的三体问题时提出了定性分析的研究方向，这是“混沌“的启蒙思想。陈老师讲三维空间有四种状态：发散，收敛，周期振荡，第四种即“混沌”。数学家Stephen Smale提出了“马蹄理论”又是“混沌数学”领域的一重要理论。我粗略地把“马蹄理论”理解成一个马蹄形状被压缩，拉伸，对折变换，不断重复这一过程，就变成了“chaos”。华人数学家李天岩发表了论文“Period Three Implies Chaos”标志着“离散混沌数学理论的诞生”。这个理论被称为“李.约克理论”。它的核心部分是“区间中存在不可数个初始点，函数从这些点出发的迭代点序列既不是周期的，又不趋向于任何周期轨道。序列的这种特殊状态是混沌的(chaotic)”。“混沌理论”这个概念在大陆由北京大学的朱照宣教授引入。

陈老师在讲混沌理论的历史发展的故事中穿插了小故事给听众解释混沌理论。陈老师举了一个足球场的例子。一个四周用铁丝网封闭的足球场，一群小孩子在足球场内踢足球。这个足球飞向什么位置是不可预测的。这就近似一个“混沌系统”。我自己的理解，在每一个时间点如果可以知道小孩踢球的位置和力量大小以及风速等等物理量，就可以预测出皮球的运动方向啊。唔，我想得岂不是跟拉普拉斯的理论一样了啊—机械决定论！！！要被自然辩证法老法鄙视的啊！为了不违反自然辩证法的原则。你要想修补我的想法。这应该是一个视角的问题。如果能得到各种影响物理量的精确值固然可以测出皮球的运动方向，但对于一个非常复杂的系统，要得到所以物理量的精确值是不可能的，于是“混沌”就同来了。“混沌“，真是好高深的理论啊！！！

陈老师在结束部分讲了“混沌理论”在天体物理学中的应用。Princeton University 的 Peter Goldreich 认为认为太阳系行星的共振是混沌的；混沌决定了太阳系行星的形成，导致地球上的某些“生物种类灭绝” 甚至某些天体的“物质消亡” ，让天体的“牛顿时钟” 最终趋于混沌。幻灯片播放的太阳系(Solar System)的图片相当地漂亮啊。最新的混沌理论认为太阳系起始于混沌状态，在两亿年内又将进入混沌。由微小的扰动会引发巨大无比的突变，行星的轨道最终都趋向于混沌。天体物理学是相当的难懂，看着这些美丽神秘的宇宙深处的图片，我觉得我所具备的物理知识不足以理解宇宙中的神秘星体。从哲学的大尺度高度，任务事情都是出生，发展，高潮，最终走向毁灭。大规模有序的运动里会在局部，某些子过程中蕴含无序的过程。看似无序的过程也必有运动的规律。Actually，我不能理解，Chaotic Solar System是个什么样的system。

http://ykyi.net zausiu’s blog

提问阶段，有人问到了计算机的问题，陈老师总结为计算机不可能产生理论上真正随机的数据。这跟我的知识是一致的，计算机只能产生伪随机数。与是又想到之前看Linux内核的书，Linux内核里有一个什么什么池的东东，这个东东用来搜集所有随机发生的事件:如电流噪声，键盘中断等等用它来贡献随机数。咦，这不就能产生真正随机的数字了吗？马上又想到，这是一个看问题的尺度的问题。把时间尺度放小到内核能收集到的两次随机事件之间，这个间隔内产生的随机数依然是通过公式计算到的可预测的数字。果然还是伪随机数。又想到之间的PPT中有讲陈老师用电路可以产生真正的“混沌信号”。那么把这路电路引入到计算机体系中，不就可以产生真正的随机数了吗？唔！那就不对了呀。那只可能是：“混沌”和“随机”并不是完全相等的概念。

讲座结束后。我跟同学讨论了未来“生物计算机”的猜想。应用哲学思想的否定之否定规律。信号从过去的“模拟信号”发展到现在占统治地位的“离散信号”，必定在以后又会发展到更高层次的“模拟信号”，近似生物电神经系统的通讯发式，将完全超越现在的二进制的冯诺依曼体系的计算机。生物电的模拟信号能携带更丰富的信息，并且能够描述真正“混沌”的“模糊”状态。而现在的二进制计算机只能用精确的离散数字近似描述模糊的东西。这样的计算机有什么现实意义呢！至少就能产生真正的随机数了。肯定有意义非凡的现实意义啊。科学学术是先不负责现实意义的，那是工程师们的任务。

/////////////////

讲座题目：混沌的故事

演讲人：陈关荣教授，香港城市大学

演讲时间：12月5日上午 10:00-11:30

演讲地点：中山大学东校区信息学院楼 207室

演讲摘要：许多人都听说过，南美洲的一只蝴蝶轻轻地扇动一下翅膀可能会在美国德克萨斯州引发一场龙卷风。这一通俗解释作为“混沌”的代名词经历了人们认识和建立科学意义上的混沌理论的漫长历程，理解到“蝴蝶效应”是混沌的一个基本特征。本讲座以故事的形式向理工科师生介绍混沌的基本概念和混沌理论的发展历史。报告力求通俗生动而不失严谨清晰。内容并不要求听众具有混沌知识，因而也欢迎其他有兴趣的非理工科师生参加。

演讲人简介

陈关荣教授1981年获中山大学计算数学硕士学位，是中大校友。他于1987年获美国Texas A&M 大学应用数学博士学位，其后在莱斯大学和休斯顿大学任教。自2000年起，他接受香港城市大学讲座教授职位工作至今，在该校成立了“混沌与复杂网络”学术研究中心并担任中心主任。他长期从事非线性科学研究，自1981年以来，发表了多篇SCI杂志论文和出版了多部研究专著，他引次数达一万六千多次，SCI h指数为 62，被ISI评定为工程学高引用率研究人员。

陈关荣教授现任IEEE《电路与系统》杂志（IEEE Circuits and Systems Magazine）主编和国际《分岔与混沌》杂志（International Journal of Bifurcation and Chaos）主编，曾经担任过许多国际学术会议主席和组织者、曾任IEEE电路与系统学会非线性电路与系统技术委员会主席。他是IEEE Fellow（自1996年），曾获4 次SCI最佳杂志论文奖，2008年获国家自然科学二等奖（第一完成人），2010年获何梁何利科学与技术进步奖，2011年获俄罗斯圣彼得堡国立大学授予荣誉博士学位和俄罗斯欧拉基金会颁发欧拉金质奖章。他是中山大学等国内外多所大学的荣誉或客座教授，并曾多次应邀到过30多个国家讲学。

sicily 1022 Poor contestant Prob 解题报告。

Mon, 05 Dec 2011 13:27:27 +0000

解题报告

1 1022 Poor contestant Prob原题中文大意;

对于大约十万条数据：如果共奇数条数据则找到最中间那条记录。如果有偶数条记录则忽略。

2 算法思想及解题用到的主要数据结构;

因为数据的规模比较大。如果给十万条记录排序的话显然会超时。考虑到题目只需要找到最中间那条。易想到把数据平分成两部分，第一部分的数据全部大于第二部分的数据。创建两个堆结构。第一部分的较大数据建大小顶堆，第二部分的较小数据建成大顶堆。在插入数据的过程中，动态维护这两个堆，使小顶堆的元素数等于大顶堆的元素数或者小顶堆的元素比大顶堆的元素多一。本题用性线表来存储堆。

3 详细解题思路;

因为最终需要输出一个字符串。为了节省拷贝字符串的开销，把字符串存到一个字符串池中，而每个堆中的元素只维护这个字符串池的索引号。

初始时，小顶堆和大顶堆的大小都是0。

1. 当输入第一条数据时，把这条数据放入小顶堆中。

2. 当输入更多数据时：

2.1 如果小顶堆和大顶堆的元素个数一样多。为保证添加新数据后，我们需要的最中间的数据在小顶堆的上部。又分两种情况处理：

2.1.1 如果待加入数据大于或等于大顶堆的堆顶元素。则把这个待加入数据加入小顶堆。调整小顶堆.

2.1.2 如果待加入数据小于大顶堆的堆顶元素.则把大顶堆的堆顶元素弹出添加到小顶堆，调整这两个堆。之后，把待加入数据加入大顶堆。

2.2 如果小顶堆和大顶堆的元素个数不一样多。因为前面的约定，那么必定是小顶堆的元素个数比大顶堆的元素个数多一个。仍然分两种情况：

2.2.1 如果待加入数据大于小顶堆的堆顶元素。则把待加入数据加入小顶堆并调整，调整后把小顶堆的堆顶弹出加入大顶堆并调整。小顶堆在弹出堆顶元素后再调整一次。

2.2.1 如果待加入数据不大于小顶堆的堆顶元素。则把该数据加入大顶堆，调整大顶堆。

输入结束时直接取小顶堆的堆顶元素即要求的解。根据元素中的字符串索引可以拿到需要打印的字符串，本题中即那位poor contestant。

4 逐步求精算法描述（含过程及变量说明）;

int g_name_pool_index = 0;   // 名字池的当前索引号.
char g_name_pool[100001][11];  // 用来存名字的字符串池.
下面是堆相关的描述。
struct heap_elem_t
{
// string _name;
int _name_index;  // 名字的索引
int _solved_count;  // 原题意中表示解决了多少个问题.用这个数量比较堆元素的大小。
};
// STL 用的堆算法的比较算子.
struct heap_elem_less_comparator
{
bool operator()(const heap_elem_t& left,  const heap_elem_t& right)
{
return left._solved_count < right._solved_count;
}
};
// STL 用的堆算法的比较算子.
struct heap_elem_larger_comparator
{
bool operator()(const heap_elem_t& left,  const heap_elem_t& right)
{
return left._solved_count > right._solved_count;
}
};
heap_elem_less_comparator less_comp;
heap_elem_larger_comparator larger_comp;
// 从下往而上调整堆。用到了STL的堆调整算法。堆元素存在线性表中，但不用第一个元素。因为之前的版本用自己写的堆调整算法为了计算坐标方便就不用第一个元素。
inline void adjust_heap_up(heap_elem_t heap[], int tail_pos, bool inc)
{
if ( inc )
{
push_heap(heap+1, heap+tail_pos+1, larger_comp);
}
else
{
push_heap(heap+1, heap+tail_pos+1, less_comp);
}
}
// 把堆顶元素弹出.并调整余下的元素仍然是一个堆。也用了STL的算法.
inline void popup_the_top(heap_elem_t heap[], int tail_pos, bool inc)
{
if ( inc )
{
pop_heap(heap+1, heap+tail_pos+1, larger_comp);
}
else
{
pop_heap(heap+1, heap+tail_pos+1, less_comp);
}
}
// 下面是自已写的堆调整算法。有从上而下的调整，也有从下而上的调整。
/** 调整堆.从下往下调整.


@param heap 堆的首地址.用顺序表存放堆.但不用下标为0的元素.这个元素可用来作临时存储.


@param summit_pos 堆顶的位置.summit_pos > 0


@param tail_pos 最后一个元素的位置.tail_pos > 0


@param inc 是否建小顶堆.如果false则大顶堆.


*/
void adjust_heap_top2bottom(heap_elem_t heap[], int summit_pos, int tail_pos, bool inc)
{
int i;
heap[0] = heap[summit_pos];  // 存下堆顶的元素先.
for ( i = 2 * summit_pos; i <= tail_pos; i *= 2 )
{
if ( inc )  // 调整小顶堆
{
if ( i < tail_pos && heap[i]._solved_count > heap[i+1]._solved_count )
i++;
if ( ! (heap[0]._solved_count > heap[i]._solved_count) )
break;
}
else  // 调整大顶堆
{
if ( i < tail_pos && heap[i]._solved_count < heap[i+1]._solved_count )
i++;
if ( ! (heap[0]._solved_count < heap[i]._solved_count) )
break;
}
heap[summit_pos] = heap[i];
summit_pos = i;
}
heap[summit_pos] = heap[0];
}
/** 调整堆.从下往上调整.


@param heap 堆的首地址.用顺序表存放堆.但不用下标为0的元素.这个元素可用来作临时存储.


@param tail_pos 最后一个元素的位置.tail_pos > 0


@param inc 是否建小顶堆.如果false则大顶堆.


*/
void adjust_heap_bottom2top(heap_elem_t heap[], int tail_pos, bool inc)
{
int i;
heap[0] = heap[tail_pos];
for ( i = tail_pos; i > 1; i /= 2 )
{
int parent_pos = i / 2;
if ( inc )  // 调整小顶堆
{
if ( heap[parent_pos]._solved_count > heap[0]._solved_count )
{
heap[i] = heap[parent_pos];
}
else
{
break;
}
}
else  // 调整大顶堆
{
if ( heap[parent_pos]._solved_count < heap[0]._solved_count )
{
heap[i] = heap[parent_pos];
}
else
{
break;
}
}
}
heap[i] = heap[0];
}
5 程序注释清单（重要过程的说明）;
// poor_guy.cpp : Defines the entry point for the console application.
//
#include <algorithm>
#include <string>
#include <vector>
#include <string.h>
#include <stdio.h>
using namespace std;
template<typename T> class my_vector
{
public:
my_vector(T* addr)
{
m_ary = addr;
m_ava_idx = 0;
}
~my_vector()
{
//  delete []m_ary;
}
T& operator[](int index)
{
return m_ary[index];
}
void push_back(const T& v)
{
m_ary[m_ava_idx++] = v;
}
void resize(int size)
{
m_ava_idx = size;
}
void shrink(int dec)
{
m_ava_idx -= dec;
}
int size()
{
return m_ava_idx;
}
private:
T*   m_ary;
int  m_ava_idx;
};
// 堆的结点定义
int g_name_pool_index = 0;
char g_name_pool[100001][11];
struct heap_elem_t
{
// string _name;
int _name_index;
int _solved_count;
};
heap_elem_t g_heap_elems0[50002];
heap_elem_t g_heap_elems1[50002];
struct heap_elem_less_comparator
{
bool operator()(const heap_elem_t& left,  const heap_elem_t& right)
{
return left._solved_count < right._solved_count;
}
};
struct heap_elem_larger_comparator
{
bool operator()(const heap_elem_t& left,  const heap_elem_t& right)
{
return left._solved_count > right._solved_count;
}
};
heap_elem_less_comparator less_comp;
heap_elem_larger_comparator larger_comp;
//
/ inc 为真时调整为小顶堆，为false时调整为大顶堆。                      /
//
inline void adjust_heap_up(heap_elem_t heap[], int tail_pos, bool inc)
{
if ( inc )
{
push_heap(heap+1, heap+tail_pos+1, larger_comp);
}
else
{
push_heap(heap+1, heap+tail_pos+1, less_comp);
}
}
inline void popup_the_top(heap_elem_t heap[], int tail_pos, bool inc)
{
if ( inc )
{
pop_heap(heap+1, heap+tail_pos+1, larger_comp);
}
else
{
pop_heap(heap+1, heap+tail_pos+1, less_comp);
}
}
int main(int argc, char* argv[])
{
const int BUFF_LEN = 64;
char buff[BUFF_LEN];
int case_count;  // 记有多少个case;
int contestant_count;
my_vector<heap_elem_t> littletop_heap(g_heap_elems0);
my_vector<heap_elem_t> bigtop_heap(g_heap_elems1);
heap_elem_t contestant;
string name;
// vector<string> output_vec;
scanf("%d", &case_count);
for ( int i = 0; i < case_count; i++ )
{
littletop_heap.resize(1);  // 为了方便计算.下标0的位置不存堆的元素.
bigtop_heap.resize(1);
g_name_pool_index = 0;
contestant_count = 0;
while(true)
{
scanf("%s", buff);
int little_heap_count = littletop_heap.size() - 1;
int big_heap_count = bigtop_heap.size() - 1;
if ( buff[0] == 'Q' )  // 查询. Querry
{
if ( little_heap_count == big_heap_count || 0 == contestant_count )
{
printf(“No one!\n”);
//output_vec.push_back(“No one!\n”);
}
else
{
printf("%s\n", g_name_pool[littletop_heap[1]._name_index]);
//output_vec.push_back(g_name_pool[littletop_heap[1]._name_index]);
//output_vec.push_back("\n");
}
}
else if ( buff[0] == 'E' )  // 结束.
{
if ( little_heap_count == big_heap_count || 0 == contestant_count )
{
printf(“Happy BG meeting!!\n”);
//output_vec.push_back(“Happy BG meeting!!\n”);
}
else
{
printf("%s%s",g_name_pool[littletop_heap[1]._name_index], " is so poor.\n");
//output_vec.push_back(g_name_pool[littletop_heap[1]._name_index]);
//output_vec.push_back(" is so poor.\n");
}
break;
}
else if( buff[0] == 'A' )// 加入参赛者数据.
{
contestant_count ++;
scanf("%s", g_name_pool[g_name_pool_index]);
contestant._name_index = g_name_pool_index;
g_name_pool_index++;
scanf("%d", &contestant._solved_count);
if ( 1 == contestant_count )  // 第一个参赛者数据.
{
littletop_heap.push_back(contestant);
}
else if ( little_heap_count == big_heap_count )  // 两个堆的元素相等.
{
// 新元素大于大顶堆的堆顶元素，所以插入小顶堆.
if ( contestant._solved_count >= bigtop_heap[1]._solved_count )
{
littletop_heap.push_back(contestant);
adjust_heap_up(&littletop_heap[0], littletop_heap.size()-1, true);
}
else
{
heap_elem_t top = bigtop_heap[1];
popup_the_top(&bigtop_heap[0], bigtop_heap.size()-1, false);
bigtop_heap.shrink(1);
bigtop_heap.push_back(contestant);
adjust_heap_up(&bigtop_heap[0], bigtop_heap.size()-1, false);
littletop_heap.push_back(top);
adjust_heap_up(&littletop_heap[0], littletop_heap.size()-1, true);
}
}
else  // 不等.只可能是小顶堆比大顶堆多1.
{
if ( contestant._solved_count > littletop_heap[1]._solved_count )
{
littletop_heap.push_back(contestant);
adjust_heap_up(&littletop_heap[0], littletop_heap.size()-1, true);
heap_elem_t top = littletop_heap[1];
popup_the_top(&littletop_heap[0], littletop_heap.size()-1, true);
littletop_heap.shrink(1);
bigtop_heap.push_back(top);
adjust_heap_up(&bigtop_heap[0], bigtop_heap.size()-1, false);
}
else
{
bigtop_heap.push_back(contestant);
adjust_heap_up(&bigtop_heap[0], bigtop_heap.size()-1, false);
}
}
}
}
if ( i + 1 < case_count )
{
printf("\n");
//output_vec.push_back("\n");
}
}
//for ( int i = 0; i < output_vec.size(); i++ )
//{
// cout << output_vec[i];
//}
return 0;
}

//////// 上面的代码在中山大学ACM网站 www.soj.me 上通过.目前的成绩是第14名.

Rank 14 2011-12-07 10:00:19 0.18 sec 2160 KB 6971 Bytes C++ zausiu

注意上面的代码绝不能用C++的标准IO cin cout 做输入输出.如果用C++的IO流会造成超时。我为了调这个超时问题调了整整一天！死活想不到是因为C++ IO的问题.童鞋，一定要用 scanf 和 printf 啊。面对十万级的IO，尤其是在做ACM题，cin cout 是魔鬼。

原因是：

More should be noted about I/O operations in C++. Due to their complex underlying implementation models, cin and cout are comparatively slower than scanf and printf. The difference in performance is shown by many experiences to be more significant if the program is compiled by G++. Therefore if a problem has huge input, using cin and cout will possibly lead to Time Limit Exceed.

6 测试数据;

用一个简单的BASH脚本来创建测试用例。

#! /bin/bash
INDEX=1
SHRESHOLD=100000   // 建十万条数据.
while [ $INDEX -lt $SHRESHOLD ]
do
echo “ADD name$INDEX $RANDOM”
let “INDEX=$INDEX+1”
done

7 对时间复杂度，空间复杂度方面的分析.

时间复杂度是O(log n), 空间复杂度是 O(n).

附原题：

1022. Poor contestant Prob

Description

As everybody known, “BG meeting” is very very popular in the ACM training team of ZSU.

After each online contest, they will go out for “smoking”. Who will be the poor ones that have to BG the others? Of course, the half who solve less problems.

The rule runs well when the number of the contestants is even. But if the number is odd, it is impossible to divide them into two equal parts. It gives a dilemma to the BG meeting committee. After a careful discussion with Mr. Guo, a new rule emerged: if the number of the contestant is odd, the committee will first sort the contestants according to the number of problems they solved, and then they will pick out the middle one. This poor boy or girl will have no chance to attend the BG meeting.

Strange rule, isn`t it?

As the number of the contestants is becoming more and more large, the committee need to write a program which will pick out the poor one efficiently.

Note that: Every contestant solves different number of problems. The total number of the contestants will not exceed 10^5.

Input

There are several cases in the input. The first line of the input will be an integer M, the number of the cases.

Each case is consisted of a list of commands. There are 3 types of commands.

1. Add xxx n : add a record to the data base, where xxx is the name of the contestant, which is only consisted of at most 10 letters or digits, n is the number of problems he/she solved. (Each name will appear in Add commands only once).

2.Query :

3.End :End of the case.

Output

1.For the Query command: If the current number of contestants is odd, the program should output the poor contestant’s name currently even if there is only one contestants, otherwise, just out put “No one!” (without quotes).

2.For the End command:

If the total number of contestants in the data base is even, you should out put “Happy BG meeting!!”(without quotes),otherwise, you should out put the “xxx is so poor. ”(without quotes) where xxx is the name of the poor one.

3.Each case should be separated by a blank line.

Sample Input

Add Magicpig 100

Add Radium 600

Add Kingfkong 300

Add Dynamic 700

Query

Add Axing 400

Query

Add Inkfish 1000

Add Carp 800

End

Add Radium 100

Add Magicpig 200

End

Sample Output

No one!

Axing

Radium is so poor.

Happy BG meeting!!

Problem Source

ZSUACM Team Member

熬夜完成 sicily1153 马周游解题报告。困死哥了.

Tue, 29 Nov 2011 18:11:20 +0000

唉！！！上次交作业写错题目了，做了简单的马周游 sicily 1152。补上新的,应该是sicily 1153.为了解决规模太大的问题。加上了优化算法。

中大ACM实验题。

（1）原题中文大意

中国象棋的马按照象棋的规则在8 x 8 的棋盘上跑64步跑完所有的格子。

（2）算法思想及解题用到的主要数据结构

从每一个点往下走第二步，会有几点有效的行走位置。把当前位置记在栈里面，以深度优先的方式进入下一个有效位置。如果下一个有效位置在之前已经走过，则从栈顶弹出上一位置，恢复到调出的位置后尝试未走过的有效位置。利用函数调用时会压栈的特别，用函数递归调用即可解决问题。

软之简单的马周游，8 x 8 棋盘的规模非常大。需要在可选下一步中找到最接近正确路线的点。求该点的办法是把所以的可选点先找出，再给这些可选点按权重排序，从最优的解依次向次优，次次优…..的点试探。重点在权重的算法。这里的权重的计算法则是指一个点的下一次可走的点的个数。

主要的数据结构有：

// elocution数组在初始化后会记下每个有效位置的下一步有哪些可走位
// 置.elocution[x][0]用下标0记个数。最多8个有效可走位置。
char elocution[ELEM_COUNT][9];
// stamps数组记每个点是否已经走过了。0表示没走过，1表示走过了。
char stamps[ELEM_COUNT];
// track数组记路径的顺序。
char track[ELEM_COUNT];
通过结合stamps数组和elocution数组可以算出下一步的每个点的权重。
（3）详细解题思路


先初始化一张表。这张表记下了棋盘上所有的30个位置的下一步可走的有效位置.


写一个一般的递归调用自己的函数，表示马在走第几步时到了哪个位置，然后求出余下的所有可走位置。


余下的所有位置按照上文提到的权重排序。


对于排序后的可选点数组，按顺序依次用递归函数尝试。


递归函数有三个退出条件。1.下一个要尝试的点已经走过了，2.试完了所有的可选下一步无解。3.走到了最后一步，即得解！


（4）算法描述
初如化上文提到的elocution数组，清空stamps和tracks.从起点开始调用递归函数。
http://ykyi.net  zausiu's blog.
（5）程序注释清单
#include <iostream>
#include <cstring>
#include <cstdlib>
#include <vector>
#include <csetjmp>
//#include <cassert>
using namespace std;
#define  ROW_NUM     8
#define  COLUMN_NUM  8
#define  ELEM_COUNT ROW_NUM * COLUMN_NUM
jmp_buf jmpbuffer;  // 很深的函数递归调用时用longjmp快速退出.
// elocution数组在初始化后会记下每个有效位置的下一步有哪些可走位
// 置.elocution[x][0]用下标0记个数。最多8个有效可走位置。
char elocution[ELEM_COUNT][9];
// stamps数组记每个点是否已经走过了。0表示没走过，1表示走过了。
char stamps[ELEM_COUNT];
struct coordinate  // 二维坐标
{
char _x;  // start from zero.
char _y;
};
// 作标转序号
char coordinate2serial_num(coordinate co)
{
char num = co._x * COLUMN_NUM + co._y + 1;
return num;
}
// 序号转坐标
coordinate serial_num2coordinate(char sn)
{
coordinate co;
co._x = (sn - 1) / COLUMN_NUM;
co._y = sn - co._x * COLUMN_NUM - 1;
return co;
}
// ((x:1;y:-2),(x:2;y:-1),(x:2;y:1),(x:1;y:2) (x:-1;y:2),(x:-2;y:1),(x:-2;y:-1),(x:-1;y:-2));
char increments[8][2] =
{
1, -2, 2, -1, 2, 1, 1, 2,
-1, 2, -2, 1, -2, -1, -1, -2
};
void next_step(char pos, char steps[])  // 把位置在pos序号的点的每一个下一个可选位置记在数组中。
{
char valid_count = 0;
coordinate co = serial_num2coordinate(pos);
coordinate tmp;
char serial_num;
for ( int i = 0; i < 8; i++ )
{
tmp._x = co._x + increments[i][0];
tmp._y = co._y + increments[i][1];
if ( tmp._x < 0 || tmp._x >= ROW_NUM || tmp._y < 0 || tmp._y >= COLUMN_NUM )  // 保证位置有效
{
continue;
}
serial_num = coordinate2serial_num(tmp);
if ( serial_num >= 1 && serial_num <= ELEM_COUNT )
{
valid_count++;
steps[valid_count] = serial_num;
}
else
{
cerr << “Not expected to reach here.\n”;
}
}
steps[0] = valid_count;
}
// 下面的逻辑以每个点的下一步可跳点的数目作为权重排序。
struct pos_weight
{
char _pos;
char _weight;
};
// 又是用递归。这里为了实现快速排序
int partition(pos_weight poses[], int low, int high)
{
pos_weight pivot = poses[low];
while (low < high)
{
while (low < high && pivot._weight < poses[high]._weight)
high–;
poses[low] = poses[high];
while (low < high && pivot._weight >= poses[low]._weight)
low++;
poses[high] = poses[low];
}
poses[low] = pivot;
return low;
}
// 快速排序。
void quick_sort_steps(pos_weight poses[], int low, int high)
{
if ( low < high )
{
int pivot_loc = partition(poses, low, high);
quick_sort_steps(poses, low, pivot_loc-1);
quick_sort_steps(poses, pivot_loc+1, high);
}
}
void rearrage_steps(char poses[], int len) // poese里放置了下一个位置数组。Len是数组长度。
{
char weight, pos, next_step_count;
vector<pos_weight> vec(len);
for ( int i = 0; i < len; i++ ) // 计算权重.
{
weight = 0;
pos = poses[i];
next_step_count = elocution[pos-1][0];
for ( int j = 0; j < next_step_count; j++ )
{
char next_step_pos = elocution[pos-1][j+1];
if ( 0 == stamps[next_step_pos-1] )
{
weight++;  // 如果有一下一跳点没走过则权重加1.
}
}
vec[i]._pos = pos;
vec[i]._weight = weight;
}
quick_sort_steps(&vec[0], 0, len-1);  // 根据权重排序.
for ( int i = 0; i < len; i++ ) // 把排序后的位置写回原始数组.
{
poses[i] = vec[i]._pos;
}
}
void init_elocution()
{
memset(stamps, 0, sizeof(stamps));
for ( int i = 1; i <= ELEM_COUNT; i++ )
{
next_step(i, elocution[i-1]);
}
}
char track[ELEM_COUNT];
void run_horse(char start_pos, char step_count) // step_count [0 – 64)
{
// 如果已经经过这点就立即退出函数。
if ( 1 == stamps[start_pos-1] )
{
return;
}
track[step_count] = start_pos;
if ( step_count == COLUMN_NUM * ROW_NUM - 1 )  // 是不是最后一步。
{
for ( int i = 0; i < sizeof(track); i++ )
{
cout << (int)track[i];
if ( i + 1 != sizeof(track) )
{
cout << " “;
}
}
cout << endl;
longjmp(jmpbuffer, 0x1);
return;
}
// 记下已经走了这一步。
stamps[start_pos-1] = 1;   rearrage_steps(elocution[start_pos-1]+1, elocution[start_pos-1][0]);
for ( int i = 0; i < elocution[start_pos-1][0]; i++ )
{
run_horse(elocution[start_pos-1][i+1], step_count+1);
}
stamps[start_pos-1] = 0;  // 试完了所有可走步.退出这个函数.重置这个位置为没有走过。
}
int main(int argc, char* argv[])
{
int pos;
vector<int> vec;
while(true)
{
cin >> pos;
if (pos==-1)
{
break;
}
vec.push_back(pos);
}
for ( int i = 0; i < vec.size(); i++ )
{
if(setjmp(jmpbuffer) == 0)  // 为了很深的递归函数快速回退到这里。
{
init_elocution();
memset(track, 0, sizeof(track));
memset(stamps, 0, sizeof(stamps));
run_horse(vec[i], 0);
}
}
return 0;
}

（6）该算法的时间复杂度是 O(8 ^ (m * n)) m,n分别为棋盘的长和宽。

/////////////////// 原题目如下:

1153. 马的周游问题

Description

和题目C同样的任务，这里只是把棋盘扩大到标准的国际象棋。对这样一个8 * 8的棋盘用同样的方法编号如下：

1 2 3 4 5 6 7 8

9 10 11 12 13 14 15 16

17 18 19 20 21 22 23 24

25 26 27 28 29 30 31 32

33 34 35 36 37 38 39 40

41 42 43 44 45 46 47 48

49 50 51 52 53 54 55 56

57 58 59 60 61 62 63 64

Input

输入有若干行。每行一个整数N(1<=N<=64)，表示马的起点。最后一行用-1表示结束，不用处理。

Output

对输入的每一个起点，求一条周游线路。对应地输出一行，有64个整数，从起点开始按顺序给出马每次经过的棋盘方格的编号。相邻的数字用一个空格分开。

Sample Input

-1

Sample Output

注意：如果起点和输入给定的不同，重复多次经过同一方格或者有的方格没有被经过，都会被认为是错误的。

又是数组越界造成的bug.

Tue, 29 Nov 2011 15:19:10 +0000

又一次遇到数组越界造成的奇怪的，难以调试的，诡异的bug.

前几天做ACM题。‘简单的马周游’。

见: http://ykyi.net/2011/11/acm-%E9%A9%AC%E5%91%A8%E6%B8%B8%E8%A7%A3%E9%A2%98%E6%8A%A5%E5%91%8A/

因为我的解法用了函数递归调用，函数求到最终解的栈的调用层次非常深。第一版用置一个全局变量的方式让这么深调用的函数快速依次退出。但我也知道还有另外一种解法就是用C语言的setjmp 和 longjmp。用这两个函数可以快速退栈。

今天晚上就想用setjmp和longjmp改写一下。本来以为是非常简单的事情。结果改完以的程序只能正确求解第一个请求，然后程序看起来就像是死了。Debug时发现程序似乎跑飞了。哎(脑子不灵光，发现程序跑飞竟然没有立即想到是数组越界把堆栈写坏了)。因为我改动的代码非常少，只是用setjmp和longjmp快速退出递归取代之前的稍微比较慢的做法。而其它的代码改动的非常之少。于是我当时分析错误的出发点就是比较两份代码的异同。比较来比较去，就只有退出方式不同而已。相当相当地困惑。费了很多时间都没有找到原因。

实在搞不定了。冲了个热水澡，又回来看代码。还是没有发现这个改动在哪里引入了错误。不断反复地看代码，突然灵光一现看到写一个全局数组的语句，下标变量越界！越界！越界！！！啊~~惊喜！于是把数组下标的相关的代码纠正了，于是setjmp版本的代码也运行正常啊。

这次的经验是。操作数组的时候一定要一定要一定要非常非常非常之小心~~在调试程序发现程序跑飞的情况下马上要意识到是写坏了堆栈。

另外还有一个疑问是第一版的代码也有写坏栈的问题为什么就一切正常呢。这就是C/C++程序数组危险的地方啊~~第一版本的代码退栈的方式和第二版不一样，于是这个bug就在第一版隐藏了起来。于是第二版出问题时我的思路集中在比较代码差异是如何引入问题的。而这个bug并不是新代码引入的，而是在旧代码隐藏起来的，第二代的新代码让触发了这个bug。

总结下经验：

一定要一定要非常小心C/C++的数组越界问题啊！！！操作很多数组时，有很多下标要计算时。千万要注意是从0还是从1开始计算下标。要根据约定多下诊断！！！及时发现隐藏的错误。越界写数组的bug有时发生，可能在引入的当时被隐藏，隐藏的很深很深。但越界读数组的bug隐藏得更深更深更深啊。

中大ACM题.商人的宣传解题报告.

Sat, 26 Nov 2011 10:35:30 +0000

Description

Bruce是K国的商人，他在A州成立了自己的公司，这次他的公司生产出了一批性能很好的产品，准备宣传活动开始后的第L天到达B州进行新品拍卖，期间Bruce打算将产品拿到各个州去做推销宣传,以增加其影响力。

K国有很多个州,每个州都与其他一些州相邻,但是K国对商人作宣传却有一些很奇怪的规定：
1、商人只能从某些州到达另外一些州，即连通路线是单向的，而且有些州可能是到达不了的。
2、商人不允许在同一个州连续宣传两天或以上，每天宣传完必须离开该州。
3、商人可以多次来到同一个州进行宣传。

“我必须找出一条影响力最大的路线才行”，Bruce想，“但我首先必须知道到底有多少这种符合规定的宣传路线可供我选择。“现在Bruce把任务交给了你。并且出于考虑以后的需要，你还要帮他算出给出的两州之间的路线的总数。

Input

输入文件第一行包含三个整数n,m,L（1≤n,L≤100），分别表示K国的州数、连通路线的数量，以及多少天后必须到达B州。接下来有m行，每行一队整数x,y（1≤x,y≤n），表示商人能从x州到达y州。
第m+2行为一个整数q（1≤q≤100），表示Bruce有q个询问。下面q行每行两个整数A,B（1≤A,B≤n），即A、B州的位置。

Output

输出文件包含q行，每行一个整数t，为所求的从A州到B州满足上述规定的路线总数。
输入数据中的询问将保证答案t在长整数范围内，即t<2³¹。

Sample Input

Sample Output

2 1

1. 原题中文大意.

商人的宣传即是一个有向图的问题。有一个有向图。该图的每条件权重一样，从图中任意一点a刚好通过L步到达另一点b有多少条路线。

2. 算法思想及解题思路.

使用了动态规划算法。令 dp[num][dest] 表示从起点通过 num 条边到达终点共有多少种走法。

先由已经知条件易得从起点通过一条它的邻接边到达它的所有邻接点共有一条路线。即 dp[1][邻接点] 易求得。而 dp[x][y] = sum( dp[x-1][可以一条邻接边到达y的点] )。

3. 主要数数据结构.

主要数据结构为三个数组。这本个数组都不用下标为的元素。

char odgree[MAX_VERTICES_NUM+1];

下标为每个顶点的编号.表示每个顶点的出度.

int routine[MAX_VERTICES_NUM+1][MAX_VERTICES_NUM+1];

‘路由表’ routine[x][n] = y 表示从顶点x经它的第n条邻接边可以到达顶点y.

int dp[MAX_VERTICES_NUM+1][MAX_VERTICES_NUM+1];

这个数组即第二节提到的dp数组，dp[L][x] = num从起点开始经L条边走到顶点 x 共有 num 种走法。

4. 逐步求精算法描述（含过程及变量说明）;

从已知条件初始化 odgree 和 routine 数组.

bzero(odgree, sizeof(odegree));

for(int x,y, i = 0; i < m; i++)

{

scanf("%d %d", &x, &y);

odgree[x]++;

routine[x][ odgree[x] ] = y;

}



下面的cal函数输入起点顶点和终点顶点，返回共有多少种走法。

int cal(char start, char dest)

{

memset(dp, 0, sizeof(dp));



for ( int i = 1; i <= odgree[start]; i++ )  // 遍历起点的每一条邻接边

{

dp[1][ routine[start][i] ]++;  //  初始时经过一邻接边到达别一点的走法有几种.



}



for ( int i = 2; i <= L; i++ )   // 一直走到第L步.

{

for ( int j = 1; j <= n; j++ )  // 遍历每一个顶点.

{

for ( int k = 1; k <= odgree[j]; k++ )  // 该顶点的第一条邻接边

{

// 上文提到的递推公式。

dp[i][ routine[j][k] ] += dp[i-1][j];

}

}

}



return dp[L][dest];  // 返回结果

}

5. 程序注释清单

#include <cstdio>

#include <cstdlib>

#include <memory>

#include <cstring>

#include <vector>



using namespace std;



const int MAX_VERTICES_NUM = 100;  // 最多多少个顶点.

int n, m, L, q;  // 实际n个点、m条边，L 为期限.q为有多少个询问.

static char odgree[MAX_VERTICES_NUM+1];  // 记每个点的出度.不用下标为0的元素.

static int routine[MAX_VERTICES_NUM+1][MAX_VERTICES_NUM+1];  // table[x][y] 表示x点经它的第y条边可以去到哪个点.

static int dp[MAX_VERTICES_NUM+1][MAX_VERTICES_NUM+1];  // dp[x][y] 表示经x条边，可以从某点到 y 点.



int cal(char start, char dest)

{

memset(dp, 0, sizeof(dp));



for ( int i = 1; i <= odgree[start]; i++ )  // 遍历起点的每一条邻接边.

{

dp[1][ routine[start][i] ]++;  // 初始时经过一步到达别一点的走法.

}



for ( int i = 2; i <= L; i++ )   // 一直走到第 L 步.

{

for ( int j = 1; j <= n; j++ )  // 遍历每一个点.

{

for ( int k = 1; k <= odgree[j]; k++ )  // 该点的每一个邻接点.

{

dp[i][ routine[j][k] ] += dp[i-1][j];

}

}

}



return dp[L][dest];

}



int main(int argc, char* argv[])

{

while ( EOF != scanf("%d %d %d", &n, &m, &L) )

{

memset(odgree, 0, sizeof(odgree));

for(int x,y, i = 0; i < m; i++)

{

scanf("%d %d", &x, &y);

odgree[x]++;

routine[x][ odgree[x] ] = y;

}



scanf("%d", &q);

vector<int> results;

for ( int start,dest, i = 0; i < q; i++)

{

scanf("%d %d", &start, &dest);

results.push_back(cal(start, dest));

}

for ( int i = 0; i < results.size(); i++ )

{

printf("%d\n", results[i]);

}



}

return 0;

}

6. 测试数据

4 5 6

1 2

2 3

3 4

4 1

2 4

1 4

4 2

2 1

1 3

3 4

7. 对时间复杂度，空间复杂度方面的分析、估算及程序优化的分析和改进.

本解决方法的时间复杂度为O(L*n*n)，空间复杂度为O(n*n).

用动态规划解此题的时间复杂度优于用邻接矩阵表示图然后用图的乘法解出。后者的时间复杂志为O(L*n*n*n)。

initramfs 和 initrd 的区别

Fri, 25 Nov 2011 05:21:49 +0000

Linux 2.6内核引入了一个新的feature叫做initramfs。与initrd相比,initramfs有几个好处。
initrd模拟一个磁盘(这就是它的名字的由来，initramdisk或initrd)。模拟磁盘也就同时引入了Linux的块IO子系统的开销，比如缓存(caching)，而initramfs从根本上把cache也装载(mounted)成filesystem(因此叫做initramfs).

Initramfs建立在page cahce之上，和page cache一样，会动态地自动增长和缩减尺寸来减入内存的使用量，而initrd做不到这点。
另外，不像initrd需要文件系统驱动(filesystem driver)的支持，比如EXT2 driver，如果你的initrd使用ext2。而initramfs则不需要文件系统的支持，initramfs的实现代码很简单，只是基于page cache的简单一层。

Linux的开机启动顺序

Fri, 25 Nov 2011 05:01:39 +0000

对于x86机器的Linux的启动顺序，BIOS首先从启动设备载入MBR(Master Boot Record).存在MBR里的代码就去找分区表，从活动分区读入Linux的bootloader，最常用的像Grub,其它的有LILO,SYSLINUX。
Bootloader把压缩格式的内核映象载入并把控制权交给内核映像。
内核映像自解压，启动内核！

x86处理器有两种工作模式。实模式和保护模式。在实模式，你只能够寻址1M内存。保护模式下，就复杂得多，可以作到使用处理器的很多高级特性比如分页。CPU必须从实模式转到保护模式是一个单行通道(one-way street)。你不能从保护模式退入实模式。

内核第一阶段的内核初始化是在实模式中完成的。接下来从init/main.c 中定义的 start_kernel()函数进入你保护模式。start_kernel()先初始化CPU subsystem。接下来启动存储器和进程管理。然后启动外围总线和IO设备。启动序列的最后一个阶段便是init进程被启动。这个进程是所有的Linux进程的祖先。Init进程执行用户空间的脚本。这些脚本被用来启动必要的内核服务程序。Init最后spawn一个控制台给你。于是启动就完成了。

ACM 马周游解题报告

Fri, 25 Nov 2011 04:33:50 +0000

<p>
  &nbsp;
</p>

<p>
  &nbsp;
</p>

<p>
  &nbsp;
</p>

<h3 style="text-align: left; ">
  <span style="font-size: 14px; ">简单的马周游问题</span>
</h3>

<p>
  &nbsp;
</p>

<p>
  &nbsp;
</p>

<p>
  </center> </div> 
  
  <p>
    &nbsp;
  </p>
  
  <div>
    &nbsp;
  </div>
  
  <div>
    <span style="font-size:14px;">Description</span>
  </div>
  
  <div>
    &nbsp;
  </div>
  
  <div>
    <span style="font-size:14px;">在一个5 * 6的棋盘中的某个位置有一只马，如果它走29步正好经过除起点外的其他位置各一次，这样一种走法则称马的周游路线，试设计一个算法，从给定的起点出发，找出它的一条周游路线。</span>
  </div>
  
  <div>
    &nbsp;
  </div>
  
  <div>
    <span style="font-size:14px;">为了便于表示一个棋盘，我们按照从上到下，从左到右对棋盘的方格编号，如下所示：</span>
  </div>
  
  <div>
    &nbsp;
  </div>
  
  <div>
    <span style="font-size:14px;">1 &nbsp; &nbsp; 2 &nbsp; &nbsp; 3 &nbsp; &nbsp; &nbsp; 4 &nbsp; &nbsp; 5 &nbsp; &nbsp; 6</span>
  </div>
  
  <div>
    &nbsp;
  </div>
  
  <div>
    <span style="font-size:14px;">7 &nbsp; &nbsp; 8 &nbsp; &nbsp; 9 &nbsp; &nbsp; &nbsp; 10 &nbsp; &nbsp;11 &nbsp; &nbsp; &nbsp; 12</span>
  </div>
  
  <div>
    &nbsp;
  </div>
  
  <div>
    <span style="font-size:14px;">13 &nbsp; &nbsp;14 &nbsp; &nbsp; &nbsp; 15 &nbsp; &nbsp;16 &nbsp; &nbsp; &nbsp; 17 &nbsp; &nbsp;18</span>
  </div>
  
  <div>
    &nbsp;
  </div>
  
  <div>
    <span style="font-size:14px;">19 &nbsp; &nbsp;20 &nbsp; &nbsp; &nbsp; 21 &nbsp; &nbsp;22 &nbsp; &nbsp; &nbsp; 23 &nbsp; &nbsp;24</span>
  </div>
  
  <div>
    &nbsp;
  </div>
  
  <div>
    <span style="font-size:14px;">25 &nbsp; &nbsp;26 &nbsp; &nbsp; &nbsp; 27 &nbsp; &nbsp;28 &nbsp; &nbsp; &nbsp; 29 &nbsp; &nbsp;30</span>
  </div>
  
  <div>
    &nbsp;
  </div>
  
  <div>
    <span style="font-size:14px;">马的走法是&ldquo;日&rdquo;字形路线，例如当马在位置15的时候，它可以到达2、4、7、11、19、23、26和28。但是规定马是不能跳出棋盘外的，例如从位置1只能到达9和14。</span>
  </div>
  
  <div>
    &nbsp;
  </div>
  
  <div>
    <span style="font-size:14px;">Input</span>
  </div>
  
  <div>
    &nbsp;
  </div>
  
  <div>
    <span style="font-size:14px;">输入有若干行。每行一个整数N(1<=N<=30)，表示马的起点。最后一行用-1表示结束，不用处理。</span>
  </div>
  
  <div>
    &nbsp;
  </div>
  
  <div>
    <span style="font-size:14px;">Output</span>
  </div>
  
  <div>
    &nbsp;
  </div>
  
  <div>
    <span style="font-size:14px;">对输入的每一个起点，求一条周游线路。对应地输出一行，有30个整数，从起点开始按顺序给出马每次经过的棋盘方格的编号。相邻的数字用一个空格分开。</span>
  </div>
  
  <div>
    &nbsp;
  </div>
  
  <div>
    <span style="font-size:14px;">Sample Input</span>
  </div>
  
  <div>
    &nbsp;
  </div>
  
  <div>
    <span style="font-size:14px;">4</span>
  </div>
  
  <div>
    <span style="font-size:14px;">-1</span>
  </div>
  
  <div>
    <span style="font-size:14px;">Sample Output</span>
  </div>
  
  <div>
    &nbsp;
  </div>
  
  <div>
    <span style="font-size:14px;">注意：如果起点和输入给定的不同，重复多次经过同一方格或者有的方格没有被经过，都会被认为是错误的。</span>
  </div>
  
  <div>
    &nbsp;
  </div>
  
  <div>
    &nbsp;
  </div>
  
  <div>
    <span style="font-size:14px;">（1）原题中文大意</span>
  </div>
  
  <div>
    &nbsp;
  </div>
  
  <div>
    <span style="font-size:14px;">中国象棋的马按照象棋的规则在5 x 6 的棋盘上跑30步跑完所有的格子。</span>
  </div>
  
  <div>
    &nbsp;
  </div>
  
  <div>
    &nbsp;
  </div>
  
  <div>
    &nbsp;
  </div>
  
  <div>
    <span style="font-size:14px;">（2）算法思想及解题用到的主要数据结构</span>
  </div>
  
  <div>
    &nbsp;
  </div>
  
  <div>
    &nbsp;
  </div>
  
  <div>
    &nbsp;
  </div>
  
  <div>
    <span style="font-size:14px;">从每一个点往下走第二步，会有几点有效的行走位置。 把当前位置记在栈里面，以深度优先的方式进入下一个有效位置。如果下一个有效位置在之前已经走过，则从栈顶弹出上一位置，恢复到调出的位置后尝试未走过的有效位置。利用函数调用时会压栈的特别，用函数递归调用即可解决问题。</span>
  </div>
  
  <div>
    &nbsp;
  </div>
  
  <div>
    &nbsp;
  </div>
  
  <div>
    &nbsp;
  </div>
  
  <div>
    <span style="font-size:14px;">（3）详细解题思路</span>
  </div>
  
  <div>
    &nbsp;
  </div>
  
  <div>
    <span style="font-size:14px;">1. 先初始化一张表。这张表记下了棋盘上所有的30个位置的下一步可走的有效位置.</span>
  </div>
  
  <div>
    &nbsp;
  </div>
  
  <div>
    <span style="font-size:14px;">2. 写一个一般的递归调用自己的函数，表示马在走第几步时到了哪个位置，然后尝试走余下的所有可走位置。</span>
  </div>
  
  <div>
    &nbsp;
  </div>
  
  <div>
    <span style="font-size:14px;">3. 递归函数有两个退出条件。要么下一个要尝试的点已经走过了，要么走到了最后一步，即得解！</span>
  </div>
  
  <div>
    &nbsp;
  </div>
  
  <div>
    &nbsp;
  </div>
  
  <div>
    &nbsp;
  </div>
  
  <div>
    <span style="font-size:14px;">（4）逐步求精算法描述</span>
  </div>
  
  <div>
    &nbsp;
  </div>
  
  <div>
    <span style="font-size:14px;">用一个数组记下来经过的点。</span>
  </div>
  
  <div>
    &nbsp;
  </div>
  
  <div>
    &nbsp;
  </div>
  
  <div>
    &nbsp;
  </div>
  
  <div>
    <span style="font-size:14px;">（5）程序注释清单</span>
  </div>
  
  <div>
    &nbsp;
  </div>
  
  <div>
    <pre class="brush:cpp">#include &lt;iostream&gt;

#include <cstring>

#include <cstdlib>

#include <vector>

using namespace std;

const static char row_num = 5; // 5行

const static char column_num = 6; // 6列

// 这个全局数组在初始化后会记下每30个有效位置的下一步可走位置.

// elocution[x][0]记个数。最多8个有效可走位置。

char elocution[30][9];

struct coordinate // 坐标.

{

char _x; // start from zero.

char _y;

};

// 坐标转序号的函数。

char coordinate2serial_num(coordinate co)

{

char num = co._x * column_num + co._y + 1;

return num;

}

// 序号转坐标的函数。

coordinate serial_num2coordinate(char sn)

{

coordinate co;

co._x = (sn - 1) / column_num;

co._y = sn - co._x * column_num - 1;

return co;

}

// 增量数组.

char increments[8][2] =

{

1, -2, 2, -1, 2, 1, 1, 2,

-1, 2, -2, 1, -2, -1, -1, -2

};

// 得用增量数组来计算每一个位置的下一步有效位置。记到steps里面.

void next_step(char pos, char steps[])

{

char valid_count = 0;

coordinate co = serial_num2coordinate(pos);

coordinate tmp;

char serial_num;

for ( int i = 0; i < 8; i++ )

{

tmp._x = co._x + increments[i][0];

tmp._y = co._y + increments[i][1];

if ( tmp._x < 0 || tmp._x > 4 || tmp._y < 0 || tmp._y > 5 )

{

continue;

}

serial_num = coordinate2serial_num(tmp);

if ( serial_num >= 1 && serial_num <= 30 )

{

valid_count++;

steps[valid_count] = serial_num;

}

else

{

cerr << “Not expected to reach here.\n”;

}

steps[0] = valid_count;

}

// 初始化记载所有点的下一步可走点的全局表。

void init_elocution()

{

for ( int i = 1; i <= 30; i++ )

{

next_step(i, elocution[i-1]);

}

char track[30]; // 记走过的路径.

bool quit_run_horse;

// 上文提高的递归函用函数.

void run_horse(char start_pos, char step_count)

{

if ( quit_run_horse ) // 用来快速退出深嵌套递归调用函数.

{

return;

}

for ( int i = 0; i < step_count; i++ )

{

// 已?经-经-过y这a点?了?.

if ( track[i] == start_pos )

{

return;

}

track[step_count] = start_pos; // 记下新走过的位置

if ( step_count == 29 ) // 最后一步则打印出结果。

{

for ( int i = 0; i < sizeof(track); i++ )

{

cout << (int)track[i];

if ( i + 1 != sizeof(track) )

{

cout << " “;

}

cout << endl;

quit_run_horse = true;

return;

}

for ( int i = 0; i < elocution[start_pos-1][0]; i++ )

{

run_horse(elocution[start_pos-1][i+1], step_count+1);

}

int main(int argc, char* argv[])

{

init_elocution();

int pos;

vector<int> vec;

while(true)

{

cin >> pos;

if (pos==-1)

{

break;

}

vec.push_back(pos);

}

for ( int i = 0; i < vec.size(); i++ )

{

quit_run_horse = false;

run_horse(vec[i], 0);

}

return 0;

}

TIME is SO LIMITED

Mon, 14 Nov 2011 16:05:00 +0000

TIME is SO LIMITED

I never imaged my graduate shcool life would be so busy. I ever though I would have enough time to read as many books in which I was interesting as I can. Actually there are a whopping pile of courses and homework to take. I seldom have enough time to read the books I’m planning to read. Time is so limitted, how I wish the lord would give me double the time, 24 hours a day. I would feel nervous and guilty when I was doing something which I deemed as a waste of time. I want to finish reading some books before the beginning of the following term. In order to achieve this goal I must manage my time much more efficient. As an example, time schedule every day should be more tight to reduce time fragment which are harder to use and much easiser to be wasted inadvertently.
God, give me more time ! I’m so busy.

EMC易安信2011中山大学校园宣讲

Thu, 13 Oct 2011 15:10:40 +0000

今天听了EMC易安信的招聘宣讲会。EMC是这颗星球上最领先的海量存储设备供应商哇！~不久前并购了vmware。年收益近200亿美，大概比电信巨头华为少五六十亿美金。

可能宣传不力而且EMC的产品基本上面向企业级，不像其它巨头企业一样有吸引力，到场的人稀稀拉拉就二十几个。EMC高管就来了四个哇，而由大BOSS带队！！！中大的童鞋们太不给面子了~~

先是由EMC的老大讲了点公司的情况。这货94年tsinghua毕业，加州理工博士。哎哎哎哎。。哎哎哎~~~~

然后由EMC的一个技术总监做presentation。相当明显的一儒雅型帅哥啊~~人才！人才啊!!! 同自己一比较…~~羡慕嫉妒恨！！！如果我这么优秀就好了。差太远了。上图.

最后环节，自由提问时。哥抢到了话筒。哥问大BOSS’EMC在上海，北京，成都都有研发。几时来华南设研发中心吖。’。结果令我相当地伤心啊，boss说两年内不会有这个打算。

拿Mic的是回答我提问的大BOSS哈。

另外。EMC每年20天带薪年假啊，不管新老员工。尼玛，20天带薪年假，我要疯掉啦！！！

knowledge gained from learning git.

Fri, 09 Sep 2011 10:34:25 +0000

# If you inadvertently remove a file of your working copy. Don’t worry. Git are good at recovering old versions of files, such as:
$git checkout HEAD — data

# show what the file looks like in a certain branch.
$git show branch_name:file_name

# In newer versions of Git, git diff –ours is a synonym for git diff HEAD, because it shows the differences between “our” version and the merged version. Similarly, git diff MERGE_HEAD can be written as git diff –theirs. You can use git diff –base to see the combined set of changes since the merge base, which would otherwise be rather awkwardly written as:
git diff $(git merge-base HEAD MERGE_HEAD)

Diff, Patch, and Friends(diff, patch和他们的相关工具)(第二篇)

Fri, 02 Sep 2011 05:16:30 +0000

原文 http://www.linuxjournal.com/article/1237
翻译: www.ykyi.net zausiu
接上篇

Use the diff program to avoid eyestrain and insanity:
使用diff程序来避免会令人发疯的肉眼查找。

diff -u 1 2
— 1 Sat Apr 20 22:11:53 1996
+++ 2 Sat Apr 20 22:12:01 1996
-1,9 +1,9
Ecce Eduardus Ursus scalis nunc tump-tump-tump
occipite gradus pulsante post Christophorum
Robinum descendens. Est quod sciat unus et solus
-modus gradibus desendendi, non nunquam autem
+modus gradibus descendendi, nonnunquam autem
sentit, etiam alterum modum exstare, dummodo
-pulsationibus desinere et de no modo meditari
+pulsationibus desinere et de eo modo meditari
possit. Deinde censet alios modos non esse. En,
nunc ipse in imo est, vobis ostentari paratus.
Winnie ille Pu.

Syntax Highlight in DDD DDD的语法高亮

Wed, 24 Aug 2011 00:32:07 +0000

这几天用DDD调试linux下的程序.发现DDD没有语法高亮~
于是google了一下。悲剧地发现一个贴子:

Hello!

Is it possible to enable syntax highlighting in DDD?
I searched through the Google and found this answer:
可以在DDD里开启语法高亮吗？我用谷歌搜索后发现这个答案。

Sorry, no, this isn’t possible.
The biggest problem is that Motif’s text widget doesn’t
support multiple colours, and would have to be replaced.
That would be an enormous job.
不好意思。没有！这不可能.
最大的问题是Motif的文本控件不支持多彩显示，必须把motif替换掉.
这不是一个普通的/简单的任务.

/////////////////////
悲剧啊！！！在黑白的Linux世界。………..

Is it still impossible (post date is Thu, 10 Feb 2005)?
Are there any workarounds/patches/forks?

Diff, Patch, and Friends(diff, patch和他们的相关工具)(第一篇)

Sat, 12 Feb 2011 03:29:02 +0000

原文 http://www.linuxjournal.com/article/1237
翻译: ykyi.net

“Kernel patches” may sound like magic, but the two tools used to create and apply patches are simple and easy to use—if they weren’t, some Linux developers would be too lazy to use them…
“内核补丁"听起来相当之神奇，但是有两个用来创建补丁和应用补丁的工具却简单易用。如果它们很难用的话，一些Linux开发者才懒得用它们呢。

Diff is designed to show you the differences between files, line by line. It is fundamentally simple to use, but takes a little practice. Don’t let the length of this article scare you; you can get some use out of diff by reading only the first page or two. The rest of the article is for those who aren’t satisfied with very basic uses.
diff这个工具设计成可以向你展示文件之间行与行的区别。它使用起来是相当的简单，但需要一点练习才习。你千万不要让长长的介绍文档把你吓住。你可以先只读前一两页文档，这样你就可以使用diff来开展一些工作了。余下的diff介绍文档是写给那些对基本用法非常不满的奇异人士的。 http://ykyi.net

摆明车马

Sun, 02 Jan 2011 01:32:09 +0000

#俗语
http://ykyi.net 广州话俗语.粤语俗语
摆明：清清楚楚地摆开，这里指明白讲清楚；
车马：象棋棋子。
意思是首先给给方明明白白讲清楚，以免日后误会发生争执。
%例句：我都摆明车马同佢讲楚个咯，费用由对方负责。点解仲要我哋出钱呀？（我都明明白白跟他们说清楚了，费用由对方负责。为什么还要我们出钱呀？）

白云山一担泥，眼阔肚窄

Thu, 23 Dec 2010 05:29:28 +0000

#歇后语
http://ykyi.net 广州话俗语.粤语俗语
白云山：位于广州市区北部，是个风景区；
从白云山挑一担泥下山，人们以为轻松便装得很满，谁知路远担重，往往无法完成。比喻人对东西总想多要，但实际上吃不了或用不了，无力消受。
%例句：你要得咁多，小心白云山一担泥，眼阔肚窄喔。（你要得那么多，小心消受不了啊。）

白云山蟋蟀，得把声

Wed, 22 Dec 2010 02:42:49 +0000

#歇后语
http://ykyi.net 广州话俗语.粤语俗语
白云山：位于广州市区北部，是个风景区；
得把声：只有声音，即只会叫而已。
白云山被开发以前，蟋蟀很多。广州人常去捉蟋蟀。但白云山的蟋蟀虽然叫声洪亮，却不善于打斗。人们用来比喻人只会叫喊不会做事。
%例句：你乜都唔做，成日嘈嘈闭，好似白云山蟋蟀，得把声咁啫。（你什么都不做，整天叫唤，就像一只白云山的蟋蟀那样，只会叫不会做事。）

白糖炒苦瓜

Mon, 20 Dec 2010 09:50:14 +0000

#俗语
http://ykyi.net 广州话俗语.粤语俗语
白糖是甜的而苦瓜是苦的，两样东西放在一起炒，其味道又甜又苦，比喻同甘共苦。
%例句：你哋两个十几年嚟好似白糖炒苦瓜咁，真係难得咯。（你们两个十几年来同甘共苦真难得啊！）

白蚁蛀观音，自身难保

Mon, 20 Dec 2010 09:38:22 +0000

#歇后语
http://ykyi.net 广州话俗语.粤语俗语
木雕泥塑的观音菩萨被白蚁蛀烂了，自己也保不住自己，怎么能够去保佑别人的平安呢？相当于“泥菩萨过河，自身难保”。
%例句：呢次我都白蚁蛀观音，自身难保咯，点有力量去帮你呢？（这次我都成了泥菩萨过河自身难保了，哪里有能力去帮你呢？）

白露水，冇益人

Mon, 20 Dec 2010 09:34:14 +0000

#歇后语
http://ykyi.net 广州话俗语.粤语俗语
冇益：没有益处，无利于。
白露节气，在九月七，八或九号之间，民间认为这时下雨涨水时对人和庄稼都不利。“冇益人”表示无益于他人，甚至冇损于他人。
%例句：你做呢个工程只顾你自己。白露水，冇益人。（你做这个工程只顾你自己，损害了别人。）

百足咁多爪

Sat, 18 Dec 2010 02:25:42 +0000

#俗语
http://ykyi.net 广州话俗语.粤语俗语
百足：指娱蚣。
爪：动物的腿，脚。
意思是像蜈蚣那么多脚。比喻一个人爱走动，一天到处乱走，别人很难找到他。
%例句：佢百足咁多爪，去边度揾佢呀？（他有像蜈蚣那样那么多腿，到哪里去找他呢？）

百年归老

Sat, 18 Dec 2010 02:22:42 +0000

#俗语
http://ykyi.net 广州话俗语.粤语俗语
百年归老
婉辞。指人活到一百岁以后最终逝世了，相当于普通话“百岁之后”。
%例句：等佢百年归老之后再讲啦。（等他百岁之后再说吧。）

霸巷鸡乸

Fri, 17 Dec 2010 01:29:37 +0000

#俗语
http://ykyi.net 广州话俗语
霸巷鸡乸
鸡乸：母鸡。
在街巷里称霸的母鸡。比喻霸道的人，在当地称王称霸。
%例句：你唔好若佢啊，佢係霸巷鸡乸嚟架。（你别招惹他，他是本地的小霸王。）

乸字的五笔编码是 bxgu，普通话读 nǎ 粤语读 naa4

百斤加一，有你唔多，冇你唔少

Fri, 17 Dec 2010 01:19:24 +0000

#俗语
http://ykyi.net 广州话俗语.粤语俗语
百斤加一，有你唔多，冇你唔少
挑东西时候一百斤再加多一斤，不算增加太重，减少一斤也轻不了多少。意思是有你无你都无足轻重。
%例句：你算乜嘢吖，百斤加一，有你唔多，冇你唔少。（你算什么呀，有你不算多，没你不算少。）

把口唔修

Wed, 15 Dec 2010 03:53:27 +0000

#俗语
http://ykyi.net 广州话俗语
把口唔修
修：修行，积德。
%例句：佢把口唔修，成日得罪人。（他说话缺德，老是得罪人。）

阿驼命，死都唔得掂

Wed, 15 Dec 2010 03:41:41 +0000

#歇后语
http://ykyi.net 广州话俗语
阿驼命，死都唔得掂
掂：直，妥当。
唔得掂：不能直，不得了。
驼背的人死了身体还不能直。
谐谑语，比喻遇到危难，毫无办法。
%例句：你如果搞唔好，咁就阿驼命，死都唔掂咯。（你如果这都搞不掂，那就到死都搞不掂啦！）

转:一些好听的粤语歌(新).至2010年

Sun, 12 Dec 2010 08:57:00 +0000

超合金曲 – （超好听）–蒋雅文+李逸朗《K歌是少不了的》
文字流泪 — 谢安琪+陈慧琳
钟嘉欣 – 爱得起 – 郑融〈韦雄在里面唱的几句，声音还可以〉
女生宿舍 – 望星打卦 – toby solo
唯一的你（超好听） — hotcha
男人信什么（超好听）–卫兰vs J .W
眼红馆（超好听的粤语歌~） — BOY~Z
再见不是朋友 — 邓丽欣
恋爱令人心痛（超好听）–钟嘉欣vs韦雄
没有童话（超好听）–叶文辉
花吃了这女孩 — 傅颖
吸血新世纪–羽翘
如果可以待你好 — 麦浚龙
接吻鱼的伤悲– 林颐
感激遇到你（超好听）– 胡杏儿vs黄宗泽
你瞒我瞒（超好听）–陈柏宇
I Will Be Loving You （超好听）– 陈柏宇
三位一体–方力申vs吴雨霏vs廖梦乐
钟无艳（超好听）– 谢安琪
陈某 — 周柏豪
get out(很喜欢的前奏） — 卫诗
Where Did You Go（超好听） — 邓紫棋gem
後备情人（超好听）– 区瑞强
玩玩具-（超好听） — e-kids
恋爱自由式–陈文媛vs萧正楠 <恋爱自由式主题曲>
浮夸 — 陈奕迅
眼睛不能没眼泪（超好听）– 古巨基
今天终于知道错 — 陈伟霆
我不要被你记住（超好听）–周柏豪
All About U — 邓紫棋
kong–侧田
幸运水晶 — 陈苑淇
爱不疚(溏心风暴之家好月圆） — 林峰
内疚（超好听）– EO2

阿聋卖布，唔讲呢匹pat1(笔bat1)

Sun, 12 Dec 2010 02:13:42 +0000

#歇后语
http://ykyi.net 广州话俗语
阿聋卖布，唔讲呢匹(笔)
阿聋：聋子。
唔讲：不讲。
呢匹：这一匹。
聋子卖布，因听不到顾客说的话，不论这匹那匹都一个价。广州话“呢匹”与“呢笔”音近。匹pat1, 笔bat1。而“呢笔”意思是这一件（事）。“唔讲呢匹(笔)”即不说这事。比喻跟人说话时，不愿意谈论某一话题。
%例句：得啦得啦，我哋阿聋卖布，唔讲呢匹（笔）。（行了行了，我们不讨论这个。）

阿聋送殡，唔听佢支死人笛

Fri, 10 Dec 2010 02:29:57 +0000

#歇后语
http://ykyi.net 广州话俗语
阿聋送殡，唔听佢支死人笛
阿聋：聋子。
聋子去送殡，听不到为死人吹奏哀乐的笛声。这里的“死人笛”是双关语，兼指为死人吹奏的笛声和讨厌的话语，讨厌的说教。“唔听你支死人笛”相当于普通话中的“不听你的那一套”的意思。
%例句:你唔好讲咁多咯，大家好似阿聋送殡，唔听你支死人笛架。(你别那么多废话，大家都不愿意听你的那一套了。)

阿崩咬狗虱，唔死有排慌

Wed, 08 Dec 2010 08:47:20 +0000

#歇后语
http://ykyi.net 广州话俗语
阿崩咬狗虱，唔死有排慌
阿崩：人名。
狗虱：跳蚤。
唔：不。
排：量词，阵，场；
慌：惊慌。
缺牙的人咬跳蚤，跳蚤虽然没有被咬死，也会被吓得不得了。形容人遇到惊险，侥幸不死也被吓得惊异不已。
%例句: 碰到咁大嘅灾害，真系阿崩咬狗虱，唔死有排慌咯。（碰上这么大的灾害，死不了也吓到不行。）

阿均卖大头鱼，好噏唔噏

Mon, 06 Dec 2010 02:28:27 +0000

#俗语。
http://ykyi.net 广州话俗语
阿均卖大头鱼，好噏唔噏
阿均：人名。
噏：嘴巴嗡动，比喻说话。
唔：不。
阿均卖大头鱼，有顾客看到他的鱼嘴巴不动，嫌鱼不新鲜不买。顾客离去后，鱼的嘴巴又动了，阿均气得骂鱼：“你好噏唔噏”，意思是嘴巴该动时不动，不该动时却动。人们用这话来责备人该说话的时候不说，而不该说的时候又说了。
%例句: 喺贵宾面前，你讲话要注意，咪学阿均卖大头鱼，好噏唔噏。(在贵宾前面，说话要注意点，别不该说的乱说。)

阿保阿胜

Sun, 05 Dec 2010 03:14:19 +0000

#俗语。
http://ykyi.net 广州话俗语
阿保阿胜
阿何阿胜泛指任何一个人，随便哪个人，相当于“张三李四”, “tom, jack”。
%例句: 呢啲工作阿保阿胜都做得啦(这些工作张三李四都可以做的。)

阿波校灯，有着有唔着

Sat, 04 Dec 2010 02:35:37 +0000

#歇后语。
http://ykyi.net 广州话俗语
阿波校灯，有着有唔着
阿波：人名。
校: 调整校正，安装。
着: 点亮(灯火)。
唔: 不。
阿波安装电灯，由于技术不过关或者责任心不强，有的亮有的不亮。比喻人在某一事中有对的地方也有不对的地方。
%例句: 呢件事你系阿波校灯，有着有唔着，唔能够乜都怪人哋。(这件事你有对的地方也有不对的地方，不能够全怪别人。)

阿崩养狗，转性

Thu, 04 Nov 2010 16:06:24 +0000

#歇后语。
http://ykyi.net 广州话俗语
阿崩养狗，转性
阿崩：豁嘴或缺门牙的人。
转性：性变性格，转变脾气。
传说阿崩很讨厌跳蚤，但缺少门牙抓了跳蚤也难以把它咬死。狗身上很多跳蚤，照理阿崩是不应养狗的，现在居然养起狗来了，人们便认为他的性格变了。多用来比喻小孩由淘气变为懂事。
%例句: 你个仔呢排好似阿崩养狗，转性咯噃(你的儿子近来似乎有点变得懂事了。)

阿崩买火石，噭过先知

Wed, 03 Nov 2010 05:21:25 +0000

#歇后语。
http://ykyi.net 广州话俗语
阿崩买火石，噭过先知
阿崩：豁嘴或缺门牙的人。
阿过: 碰撞过。
先知: 才知道
阿崩买火石要把火镰同火石互相碰撞一下，才知道这火石的优劣。比喻人们要经过互相较量，才知道谁强谁弱。
%例句: 我话边个队赢都好难讲，唯有阿崩买火石，噭过先知啦。(我说哪一个队赢都很难讲，只有较量过才能知道。)

阿崩叫狗，越叫越走

Tue, 02 Nov 2010 12:41:03 +0000

#歇后语。
http://ykyi.net 广州话俗语
阿崩叫狗，越叫越走
阿崩：豁嘴或缺门牙的人。
走: 离去。
缺了门牙的人叫狗，狗听不清主人叫它做什么，以为是赶它走。形容小孩不听人叫唤，叫他来反而离去。
%例句: 佢哋唔知係唔係怕我，个个都系阿崩叫狗，越叫越走。(他们不知是不是怕我，个个都越叫越不愿意来。)

fsockopen真好用,PHP的高级别网络函数！

Mon, 01 Nov 2010 16:42:36 +0000

今天用Burp工具分析了一个网站的大致功能后打算写程序把该网站我感兴趣的内容全抓下来。
一开始用java写了一小段，但哥对Java不熟悉哇，而且哥觉得Java的那么多流的类，如果仅仅操作文本文件，就显得封装的太厚了。又想，用C/C++写。虽然用C/C++写的最多代码，但事实上C/C++的字符串操作一想起来就嫌烦，而且正则式也烂得可以，数组不支持用字符串索引也真够麻烦，虽然可用C++的std::map容器。最后决定用PHP写…PHP真是太好用了~~~犹赞超强大的正则式，同perl的正则式有得一拼啊。如果换用标准C字符串函数和GNU的一个超难用的C正则式库，那要写死人啊~~~

最开始的思维定势就是要先开一个socket(N多参数要填入), 省略bind(操作系统自已选一个本地端口绑定)，第二步 connect 到主机，第三步往 socket 里写东西… 虽然只几个简单函数，但要填的几个参数也真够难记的。嘿，偶像发现事实上PHP提供了high-level的socket函数 fsockopen()。哇，太方便了。

fsockopen()
returns a file pointer which may be used together with the other file functions (such as fgets(), fgetss(), fwrite(), fclose(), and feof())
fsocketopen返回一个文件指针，然后就可以用常用的文件函数操作它啦！！！和操作文本一件一样~~~ 比 Java 的 java.io.socket 类还要方便~~虽然java也抽象的不错，但我就是嫌流对象封装太厚了。人生苦短，何必自找麻烦呢。
用完以后用 fclose 把它fsockopen返回的文件指针关掉！

看个例程:

$fp = fsockopen(“udp://127.0.0.1”, 13, $errno, $errstr); if (!$fp) { echo “ERROR: $errno – $errstr \n”; } else { fwrite($fp, “\n”); echo fread($fp, 26); fclose($fp); } ?>

上面的例程从本机的UDP时间服务器里读取当时的时间和日期。如果你本机开了标准的时间服务的话~~~

阿崩吹箫，嘥声坏气

Mon, 01 Nov 2010 15:43:19 +0000

#歇后语。
http://ykyi.net 广州话俗语
阿崩吹箫，嘥声坏气
阿崩：豁嘴或缺门牙的人。
嘥：浪费。
缺门牙的人吹箫，又费气力又吹不好。形容说话没有结果，白费唇舌。
%例句: 讲咁多佢一句都听唔入，真系阿崩吹箫，嘥声坏气咯。(说了那么多，他一句也没听进去，真是白说了。)

tcpdump基础教程

Sun, 31 Oct 2010 05:34:49 +0000

英文原文出自： A tcpdump Tutorial and Primer
翻译: ykyi.net

Tcpdump是信息安全专业人士最重要的一个网络分析工具。对这个工具有一个深入的理解对于每一个喜欢透彻理解tcp/ip协议栈的人来话都是必须的。但很多人选择一个更高级别的工级，比如Ethereal Wireshark，但是我认为这是一个错误！

不应该机械的反复记忆概念而应该做到真正的理解，因为对tcp/ip协议簇保持清醒的认知非常的重要。如果对该协议簇能够完全精通，那你调试网络的能力则能比同行们高出几个档次。但是，要学精神tcp/ip协议簇，只有不够的实践剖析它们才能做到。

当你使用某种工具来显示网络中的原始流量信息时，人类，而不是机器，就要承担起分析这些流量的重任了。用这种方法就可以不断地加深对tcp/ip的理解。并且，用这种学习方法的时候，我在任何可能的情况下都强烈主张使用tcpdump而不是其它工具。

选项
下面将列出一些用例子的选项，这样可以在你使用这个工具时对你有很大的帮助。这些选项很容易淡忘或与其它类型的滤镜(Filter,笔者认为这里的滤镜实际上指的是其它网络工具)混淆。比如, ethereal。所以，希望这篇文章可以作为一个参考文档，我就是这样使用它的。

首先，我要先介绍几个我认为很方便的tcpdump的选项。第一个是 -n, 这样的话域名就不会被解析了，而是用数字IP的形式显示地址(译者注: 同netstat的-n是一样的喔)。第二个是 -X, 这样就会同时把包的内容以ASCII码和十六制的形式显示。最后一个是 -S, 它个选项会显示绝对序号而不是相对序号。因为当包被隐藏起来的话，你也不会看到奇怪的序号。请谨记，tcpdump较之其它工具的优势之一就是可以与包(packets)手工交互。

值得注意的是，tcpdump默认只会从packet中取出前96个字节。如果你想要多一些的话，那就需要需要把 -s xxxx 加上。这里的xxxx是你确切想要抓取的总字节数。如果我使用这个选项的话，我通常会把这个数字设定为1514而得到所有的数据。下面是一个简短的列表列出我经常使用的选项。

-i any: 监听所有的介面。这样你就知道是不是有流量产生。
-n: 不要解决主机名，以IP数字形式显示主机。
-nn: 不要解析主机名或端口名字。

-A: 以ASCII字符显示包的数据。
-X: 同时以十六进制和ASCII字符显示包的数据。
-XX: 同-X,但也会显示 Ethernet头部。
-v, -vv, -vvv: 详细，更详细，再详细些！冗余输出得到的包信息。
-c: 抓取 x 个包后就停下。
-S: 打印绝对序号。
-e: 同时得到Ethernet头部。
-q: 显示少一点协议信息。
-E: 用提供的密钥解密 IPSEC 流量。
-s: 设置显示前多少个字节的包内容（snaplength）。

tcpdump 4.0的snaplength的长度从68字节改成了96字节，这样你就可以看到多些内容了。但仍然看不到所有的内容，指定 -s 1514 得到包的所有内容。

http://ykyi.net
一些基本的应用
根据我要查看的不同流量，我使用不同的选项组合，如下:

1.Basic communication // see the basics without many options
tcpdump -nS

Burp套件教程(Burp Suite)

Thu, 28 Oct 2010 17:01:40 +0000

原文来自http://portswigger.net/burp/
ykyi.net 翻译

使用Burp套件(Burp Suite)
当启动Burp Suite以后，Burp的代理服务器就在本地的loopback介面上的8080端口上开始运行啦！通过设定浏览器使用这个Burp代理服务器，所有的WEB流量就可以被截获，窥视，修改。默认设置下，对非媒体资源(non-media)的请求将被截获而且显示出来(默认的设置可以在Burp Proxy的OPTION选项里修改）。所有的穿过Burp代理服务器的WEB流量将被自动分析并添加到站点地图里，这样就可以知道访问过的网站的内容和功能了。对于Burp的收费Professional版，默认情况下，所有的请求还会自动被Burp Scanner分析从而确定易受攻击的部分。

在你就要刻苦大干一场之前，你需要完美地定义出你的工作的Target Scope(Burp的术语名词，不译出)。最简单的办法就是先浏览目标网站，然后定位相关主机和目录，再使用context菜单项把URL们添加到Target Scope里。中央范围配置(Central Scope Configuration)可以用来配置各个Burp工具。

当你浏览目录WEB网站或程序的时候，你就能对截获的请求和响应进行手工编辑，或者你也可以完全关闭拦截功能。在拦截功能被关闭的情况下，每一条请求和响应仍然被记在历史记录里，所有的WEB内容也会被添加到站点地图里。

除了可以用代理修改拦截下面的讯息，你也可以把迅息发送到其它Burp工具。这样就可以完成各种各样的不同的功能，比如：

》你可以通过把请求发给Repeater来手动调节对WEB程序的测试，也可以不断地重发每个请求。
》对于Professional版，可以把请求发给Scanner，就可以完成主动和被动漏洞扫描。
》你可以把请求发给Intruder，就可以发起一个用户自定义的自动测试来确定一些常见的漏洞。
》如果你发现响应中有会话令牌或者其它本应该是不可预测的ID号，你就可以把这个响应发给Sequencer来测试这个令牌的随机性。
》可以把请求或响应中被模糊化处理的数据发给Decoder来尝试自动解析出明文。
》对于Professional版，你可以使用各种Engagement工具来提高你的工作效率。
对于代理的历史记录，站点地图中的主机·目录·文件以及Burp工具的任何显示请求和响应的地方你都可以执行以上任何操作。

中央日志功能(central logging function)记录下来每个Burp工具的所有的响应和请求。每个Burp工具都可以在单独的窗口中运行也可以在TAB WINDOW下运行。每个工具和整个套件的配置可以被保存下来重复使用。对于Professional版，你还可以保存每个工具的状态，这样你就可以随心所欲的重新载入之前保存的状态。

怎么学粤语

Mon, 25 Oct 2010 12:36:39 +0000

经常有人问怎么才能学好粤语，也经常听到很多人说:听多D讲多D就识啦~ 其实不是这样的，最多只能说部分正确。下面以我的经验告诉你怎么学好粤语。

我来广东之前也不会讲广东话，更要命的我还以为自己唱的几首粤语歌很准，现在回想真是太可怕了。07年到广州没有正式学，一年下来还是什么都不会，大部分听不懂。后来我去了珠海。因为有一次同几个Friend吃饭，其它人都讲白话(白话在广东省指粤语)，我不懂啊，觉得不好意思大家迁就我改讲普通话。于是我那次以后开始正式决心学粤语啦！！！事实上用了三个月就基本上能够沟通了，就有人第一次赞我’讲得唔错’啦。

错误的学习方法:
对于大多数人，特别是母语不是客家话，潮汕话，闽南话的年龄在十岁以上的朋友要想仅仅靠“听多点就自然会”几乎是不可能的！只有小孩子有只靠听就能学会语言的‘人类的特有能力’。遗憾的是你不是小孩子了，你的大脑收到声音讯号就在你已经会的语言里找发音相同或相近的，但普通话同粤语的发音相差太大了，粤语还有N多自已独有的词汇。有些词或句子，如果没有人指导你，你就是听一万遍，听十万遍，你也听不懂。到了广州生活工作了十年以上还只能听懂简单粤语的人大把大把就是这个原因。还有些人说找个人教教你就会了。很难！首先找个愿意花大把时间教你的人不容易，更致命的是他们不会教。他们只会不断的告诉你，错了，不对，唔正，点解你发音好怪！但他们不知道怎样才能教会你发正确读音。几个回合下来，你和你的老师全部都精神崩溃了。老师报怨教你不会，你报怨粤语太难。你的老师于是就安慰你了:听多D讲多D就识啦！于是你再过一个星期放弃了。即使是会客家话，潮汕话，闽南话的，这几种方言的发音系统同粤语很接近，也仅仅让你容易学习很多，但这部分人中很多发音也很不正，大把人不分前后鼻音, l 和 n。

实践检验正确的学习方法:
自我经验证明行之有效的学习方法包括四个方面: 1.熟悉粤语拼音. 2.熟悉粤语基本词汇. 3.粤语歌影视做为补充. 4.有一位会纯正粤语的朋友鉴定你的发音。

1. 粤语拼音方案: http://ykyi.net/school/jyutping_crashcourse.php
首先你必须理解普通话拼音，毕竟都是汉语语系，普通话和广东话大部分声母和一半韵母是相同的。另外会英文国际音标是极好的补充！粤语里有两个英文里常用的元音，分别是æ(apple中a的发音)和 ʌ (cup中u的发音)，但普通话里没有这两个元音，有些人听到ʌ这个元音就把它当成普通话拼音里的e，有些人把它当成a。另外粤语里的入声同英文里的短元音有点类似，比如book,shit。只是类似，学到粤语入声时可以参考下。闽南语也完整保留入声系统，会闽南语的可以无视入声.会客家话和潮汕话的也基本上可以无视。还有粤语里的该字的发音基本上就是英文单词boy的发音把声母由b改成g。再之，粤语有m,n,ng三种韵尾，普通话里没有m韵尾，所以大部分学习者都把粤语里的心sam1读成身san1。歌手易欣有首粤语歌。易欣就是把‘心’唱成‘身’了。要解决这个方音问题，参考一下英语单词的gun(枪),和gum(口香糖)就豁然开朗啦！你能区分gun和gum吗？

然后你就要开始学粤语拼音啦！很多人觉得拼音很难，想跳过这一步，我还是劝你学点粤拼先，磨刀不误砍柴刀，只学了六七成也能让你学粤语时效率提高数十倍。学粤语拼音是为了学习粤语的发音系统，如果你不熟悉粤语的发声系统，很多字的读音，你就总是用自己母语或者普通话的发音系统去理解，这时候虽然你自己听起来一样，但其实读错了。比如不懂粤拼的学习者，一百个有九十八个以为粤语的‘点dim2’和‘典din2’发音是一样的。还有时还很搞笑。比如：说‘阿伯baak3’可能说成‘阿爸baa1’。言归正传，一开始你只需要了解一些粤语拼音，学会使用这个拼音工具来帮助自己理解发音和纠正发音。

2. 熟悉粤语基本词汇
这个是必须的，但也非常容易。比第一项要求要容易很多，估计只需要花你几个小时的时间。你可以买一两本粤语书教程，一般的教程基本上都讲了粤语用的日常词汇。http://ykyi.net/toubou/promote.php 这里有介绍的书中有几本我用过有些人连粤语的基本词汇都不知道就冲到QQ群里叫人教粤语。拜托，谁有那么多时间啊。点解，点样，唔该，得佐，冇，先，添这些很日常的词汇看看就会了。语法的话，虽然粤语有句式有小小不同，但基本上和普通话一样，可以无视的。大话西游里的台词"给个理由先"就是广东话的句式。

3. 粤语歌和影视，新闻媒体
听唱粤语歌和看粤语发音的影视可以让你在娱乐中培养你的听觉系统把某些发音同各个汉字建立联系。因为普通话的发音同粤语话相去甚远，你需要听唱N多粤语歌和影视或者新闻来建立这个声音到字的条件反射。在这个过程中，之前你学过的一粤语拼音就要派上用场了。你听到发音的时候去想这个字的粤语拼音，在实践中理解那些你之前不懂的发音，比如 oe 是什么（实际上是国际音标中的æ）；p,t,k入声字怎么读，以及粤语的各个不同的声调等等任何你之前不理解的粤语拼音在实践中不断体会。

4. 有一个粤语老师。
这个非常重要，基本上和第一条一样重要。实际上第二，第三条你都可以略去，但第一和第四条太重要了。如果缺了第一条，仅有老师，他极有可能像此文刚开始提到的那样教不会你；如果缺了第四条，你不知道自己的发音有没有发对。比如律师的律字注音为 leot6 , 用国际音标可以注为 læt, 这个字读粤语的第六声。假如这个字你没有把握，你就去问你的老师自己发音有没有读对，然后不断的参照拼音调整自己的口腔的吐气声调，直到你的老师肯定你的发音。如果没有粤拼，你很痛苦的，你的老师也更痛苦，一个不知道哪里读错了，一个不知道怎么才让你读对。比如粤语的六个音调，你就可以选夫(fu1), 苦(fu2), 富(fu3), 扶(fu4), 妇(fu5), 父(fu6) 这六个字在同你老师交流中体会学习。韵母a, aa亦然，粤拼里的a实际上是英语音标中的ʌ，aa才是普拼和音标中的a. 以粤拼为工具在和你的老师交流过程中学习吧！

以上四个条件，互相促进！！！如果你按照这个方法做了。学会用粤语基本沟通是很容易的事情，我就是用这个方法学的，不过用了三个月的时间而已。学会唱粤语歌更加是小菜一碟了！