so true 2021-11-20 21:03 发表评论

2. __atomic_compare_exchange_n系列是新版gcc内置的，支持6种memory order；

3. std::atomic之类的是stl的封装；

4. 6种mem order，https://www.zhihu.com/question/24301047里讲得不错，概括下：

memory_order_seq_cst最严，memory_order_relaxed最松，通常是用acquire（load时）/release（store时）模式，在该大模式下：

a. 通常是读用memory_order_acquire，写用memory_order_release；

b. 如果只是针对单个变量且该变量没有依赖的变量，acquire可以弱化为consume；

c. 如果不想区分什么单变量多变量或读写状态，简单点统一用memory_order_acq_rel。

so true 2020-06-28 17:19 发表评论

1. Win10关闭快速启动；

2. Win10关闭BitLocker；

3. Win10下压缩磁盘，留出一块未分配的区域X用于安装ubuntu，再搞出一个3GB的FAT32分区，把下载好的iso镜像释放到里面；

4. BIOS关闭Secure Boot；

5. BIOS关闭SATA的RAID，设置为AHCI；

6. 启动时F12，选择那个3GB的FAT32启动（默认会自动探测到，否则在BOOT SEQUENCE里手动增加一下）；

7. 选择try Ubuntu进去进行安装；

8. 安装前先sudo umount -l /dev/xxx, xxx是光盘镜像文件所在的盘，以避免安装过程卡在detecting file systems阶段不动；

9. 安装类型选择其他选项；

10. 在预留空间X上分50GB给/，分X-80给/home，分30给swap；

11. 安装启动引导器的设备，选择Windows Boot Manager所在的分区（分区类型是EFI）；

12. 如果出现"The 'grub-efi-amd64-signed' package failed to install into /target/."之类的错误，是因为缺包，重新安装，勾选开启网络并允许下载包的选项进行安装即可；

参考文章：

so true 2019-08-19 10:26 发表评论

so true 2019-05-09 18:53 发表评论

上面这些概念的引入完全是为了解决一个问题：尽可能用浅拷贝代替深拷贝；具体该如何实施呢：

1. 定义move constructor或move operator=，如果你新定义的类没有move constructor或move operator=，那根本就用不上上面那些高级的概念；

2. 告诉编译器什么时候用move constructor（而不是用copy constructor），这就需要借助std::move来把左值转成右值；

下面是一些零散的箴言：

左值：能用&来取地址的东西（有名字的都是左值，不管其是否是const的，而且引用都是左值，因为引用肯定得起个名字去引用另外一个东西）；

右值：不能用&来取地址的东西（说白了就是没名字的东西，例如函数的返回值）；

const T&是万能引用，即 const T& t = XXX; //XXX是左值、右值都可以；

T& t = XXX; //XXX必须是左值；

T&& t = XXX; //XXX必须是右值；
const T&& t = XXX; //XXX必须是右值；

不要把T&&和const T&划等号，两个都能hold住临时变量，给临时变量续命，但：

T&& t1 = get_val();

const T& t2 = get_val();

t1和t2都是左值，因为都可以用&来取地址，但t1是非const的，因此可以t1.xxx = yyy;去修改t1里的内容（当然如果你定义const T&& t1 = get_val()，那就不能更改了），这样一来，下面这种代码受益了：

    string name = get_name(); //因为后面要修改name，所以不能用const string& name

    trim(name);

    可以修改为：

    string&& name = get_name();

    trim(name);

    

关于右值引用的生命周期（续命能续多久，下面讨论的也适用于const T&）：

1. 函数不能返回对局部变量的引用（右值引用也不行），这是铁的原则；

2. 引用一旦建立（用一个名字hold住了临时变量），例如T&& t = get_val();那么这个临时变量的析构时机就是变量t退出其作用域的时候，因此下面的代码是错误的：

    struct A {

        A(T&& t): _t(t) {};

        T&& _t;

    };

    A* pa = NULL;

    {

        T&& t = get_val();

        pa = new A(t);

    }

    pa->_t; //runtime crash, _t已经析构了

    

std::move只做一件事：把左值转成右值，因此T t(std::move(get_val()));不管什么情况下都能保证调用move constructor来构造t；

c++0x里stl的各种容器都已经新增了move constructor，因此当你希望使用浅拷贝的时候可以借助std::move来达成所愿了，至于什么时候可以用浅拷贝，分两种情况，有些情况编译器会默认帮你去调用move constructor，但在你自己新定义的函数或者类成员方法里就需要你自己来判断了，大的原则就是：这个变量只是传递过去就好，中间可以转好几道手，但在传递过程中不需要做修改；

完美转发（std::forward），谈到这个就必须得谈到通用引用（universal reference）、引用折叠（reference collapsing），其实这几个概念是捆绑在一起的，而且只用在模板范畴内，而且只是为了解决下面这一种模式：

template <typename T>

void func2(T t) {

}

template <typename T>

void func(T&& t) {

    func2(std::forward<T>(t));

}

上面这个到底完美在哪里？

func(get_val()); //这个会导致最后是通过move constructor来构造func2函数里的参数t

T t0 = get_val();

T& t1 = t0;

const T& t2 = get_val();

T&& t3 = get_val();

const T&& t4 = get_val();

func(t0); func(t1); func(t2); func(t3); func(t4); //这5个都会导致最后是通过copy constructor来构造func2函数里的参数t，因为这个5个t*都是左值（有名字的就是左值）；

    插播两个你有可能费解的地方：

    1. func函数的参数是T&&, t0、t1都是左值，不是说不能用左值赋值给右值吗？这就要提到引用折叠了（详情可参见最后我推荐的文章），说白了因为func是个模板函数才能这么干；

    2. t3类型是T&&，func的参数也是T&&，把t3传递过去，居然还是调用copy contructor，因为t3是右值引用，它引用了一个右值，但它本身却是左值，到了func函数内部，func函数只能知道它是个左值，了解不到它原本的面貌居然是个右值引用；如果还不理解，再看下下面：

    template <typename T>

    void print(T t) {

    }

    int x1 = 1; int& x2 = x1; const int& x3 = x1; int* x4 = &x1;

    分别用x{1..4}来调用print方法，你肯定知道x1、x2、x3到了print函数里，T就是int，只有x4会被print函数认为T是int*，引用这个概念在模板类型推导时是无法让模板参数感知到的；此外print(T)和print(T&)是不能同定义的，编译器会抱怨ambiguous，这个事实也能帮你多一些理解。

如果想让上面的这5个最终能通过move constructor来构造func2函数里的参数t，那么只要给每个都用func(std::move(t*))包装下就可以了；

再澄清下，func2函数的参数是类型T，并不是引用，因此无论如何都需要生成T的一个新实例，区别就是到底是通过copy constructor还是move constructor来生成了；

所以，所谓的完美就是体现在了forward能把本来是左值的按左值来传递，本来是右值的按照右值来传递，具体来说就是作为中间环节的func函数内部实现过程中使用了func2(std::forward<T>(t));这句话，使得可以按照调用方实际的真实情况告知给func2函数如何构造参数t，这有什么好处呢，还是那句话：在适当的时机做合适的引导，让编译器帮你调用浅拷贝。

除此之外，你完全可以忘掉这些玄乎其神的概念，所以只要会套用就可以了。

以上是一些梗概性或结论性的东西，再结合下面这篇文章，把骨头之外的血肉补上吧：

https://codinfox.github.io/dev/2014/06/03/move-semantic-perfect-forward/

so true 2018-12-06 11:38 发表评论

  1 #include <iostream>
  2 #include <typeinfo>
  3 #include <string>
  4 #include <fstream>
  5 #include <sstream>
  6 #include <stdint.h>
  7 #include <pthread.h>
  8 #include <unistd.h>
  9 #include <string.h>
 10 #include <vector>
 11 #include <map>
 12 #include <set>
 13 
 14 using namespace std;
 15 
 16 template<typename T>
 17 struct type_to_pointer { typedef T* type; };
 18 template <typename T>
 19 struct type_to_pointer<T*> { typedef T* type; };
 20 template <typename T>
 21 struct type_to_pointer<const T*> { typedef T* type; };
 22 template <typename T>
 23 struct type_to_pointer<T*const> { typedef T* type; };
 24 template <typename T>
 25 struct type_to_pointer<const T *const> { typedef T* type; };
 26 template <typename T>
 27 struct type_to_pointer<T**> { typedef T* type; };
 28 template <typename T>
 29 struct type_to_pointer<const T**> { typedef T* type; };
 30 template <typename T>
 31 struct type_to_pointer<T**const> { typedef T* type; };
 32 template <typename T>
 33 struct type_to_pointer<T&> { typedef T* type; };
 34 template <typename T>
 35 struct type_to_pointer<T&&> { typedef T* type; };
 36 template <typename T>
 37 struct type_to_pointer<const T&> { typedef T* type; };
 38 template <typename T, int N>
 39 struct type_to_pointer<T[N]> { typedef T* type; };
 40 template <typename T, int N>
 41 struct type_to_pointer<const T[N]> { typedef T* type; };
 42 template <typename T, int N>
 43 struct type_to_pointer<T*[N]> { typedef T* type; };
 44 template <typename T, int N>
 45 struct type_to_pointer<const T*[N]> { typedef T* type; };
 46 template <typename T, int N>
 47 struct type_to_pointer<const T *const[N]> { typedef T* type; };
 48 
 49 template <typename FromType, typename ToType = void>
 50 void type_printer() {
 51     cout << __PRETTY_FUNCTION__ << endl;
 52 }
 53 
 54 #define TYPE_PRINT(var) type_printer<decltype(var), type_to_pointer<decltype(var)>::type>()
 55 #define CONST_CAST_TO_POINTER(var) const_cast<typename type_to_pointer<decltype(var)>::type>(var)
 56 
 57 int main(int argc, char* argv[]) {
 58     int x1 = 0;
 59     TYPE_PRINT(x1);
 60 
 61     const int& x2 = x1;
 62     TYPE_PRINT(x2);
 63 
 64     const int* x3 = &x1;
 65     TYPE_PRINT(x3);
 66     TYPE_PRINT(CONST_CAST_TO_POINTER(x3));
 67 
 68     const int *const x4 = &x1;
 69     TYPE_PRINT(x4);
 70     TYPE_PRINT(CONST_CAST_TO_POINTER(x4));
 71 
 72     int& x5 = x1;
 73     TYPE_PRINT(x5);
 74 
 75     int *const x6 = &x1;
 76     TYPE_PRINT(x6);
 77     TYPE_PRINT(CONST_CAST_TO_POINTER(x6));
 78 
 79     int* x7 = &x1;
 80     TYPE_PRINT(x7);
 81 
 82     int&& x8 = 0;
 83     TYPE_PRINT(x8);
 84 
 85     int x9[2] = {1, 2};
 86     TYPE_PRINT(x9);
 87 
 88     const int x10[2] = {1, 2};
 89     TYPE_PRINT(x10);
 90 
 91     int* x11[2] = {NULL, NULL};
 92     TYPE_PRINT(x11);
 93 
 94     const int* x12[2] = {NULL, NULL};
 95     TYPE_PRINT(x12);
 96 
 97     const int *const x13[2] = {NULL, NULL};
 98     TYPE_PRINT(x13);
 99 
100     TYPE_PRINT(argc);
101     TYPE_PRINT(argv);
102     return 0;
103 }

so true 2018-11-08 19:03 发表评论

#include <string>

#include <fstream>

#include <sstream>

#include <stdint.h>

#include <pthread.h>

#include <vector>

#include <map>

#include <set>

using namespace std;

long g_idx = 0;

class ThreadRwLock {

private:

    pthread_rwlock_t m_rw_mutex;

public:

    ThreadRwLock() {

        pthread_rwlockattr_t attr;

        // 设置写优先

        pthread_rwlockattr_init(&attr);

        //pthread_rwlockattr_setkind_np(&attr, PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP);

        pthread_rwlock_init(&m_rw_mutex, &attr);

    }

    ~ThreadRwLock() {

        pthread_rwlock_destroy(&m_rw_mutex);

    }

    void rdlock() {

        pthread_rwlock_rdlock(&m_rw_mutex);

    }

    void wrlock() {

        pthread_rwlock_wrlock(&m_rw_mutex);

    }

    int tryrdlock() {

        return pthread_rwlock_tryrdlock(&m_rw_mutex);

    }

    int trywrlock() {

        return pthread_rwlock_trywrlock(&m_rw_mutex);

    }

    void unlock() {

        pthread_rwlock_unlock(&m_rw_mutex);

    }

};

ThreadRwLock g_lock;

void* thread_routine(void* arg) {

    long is_write = (long)arg;

    if (is_write) {

        printf("%lu wait write lock\n", pthread_self()); fflush(stdout);

        g_lock.wrlock();

        long idx = __sync_add_and_fetch(&g_idx, 1);

        printf("%lu get write lock, %ld\n", pthread_self(), idx); fflush(stdout);

        sleep(5);

        g_lock.unlock();

    } else {

        printf("%lu wait read lock\n", pthread_self()); fflush(stdout);

        g_lock.rdlock();

        long idx = __sync_add_and_fetch(&g_idx, 1);

        printf("%lu get read lock, %ld\n", pthread_self(), idx); fflush(stdout);

        sleep(5);

        g_lock.unlock();

    }

    return NULL;

}

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

    pthread_t tid = 0;

    pthread_create(&tid, NULL, thread_routine, (void*)0);

    pthread_create(&tid, NULL, thread_routine, (void*)0);

    pthread_create(&tid, NULL, thread_routine, (void*)0);

    pthread_create(&tid, NULL, thread_routine, (void*)0);

    pthread_create(&tid, NULL, thread_routine, (void*)0);

    pthread_create(&tid, NULL, thread_routine, (void*)1);

    getchar(); //让程序暂停，等待键盘敲入一个字节后，接着走

    pthread_create(&tid, NULL, thread_routine, (void*)1);

    sleep(2); //确保写锁被优先拿到

    pthread_create(&tid, NULL, thread_routine, (void*)0);

    pthread_create(&tid, NULL, thread_routine, (void*)0);

    pthread_create(&tid, NULL, thread_routine, (void*)1);

    pthread_create(&tid, NULL, thread_routine, (void*)1);

    pthread_create(&tid, NULL, thread_routine, (void*)1);

    pthread_create(&tid, NULL, thread_routine, (void*)1);

    pthread_create(&tid, NULL, thread_routine, (void*)1);

    pthread_create(&tid, NULL, thread_routine, (void*)0);

    pthread_create(&tid, NULL, thread_routine, (void*)0);

    pthread_create(&tid, NULL, thread_routine, (void*)1);

    pthread_create(&tid, NULL, thread_routine, (void*)1);

    pthread_create(&tid, NULL, thread_routine, (void*)1);

    pthread_create(&tid, NULL, thread_routine, (void*)1);

    pthread_create(&tid, NULL, thread_routine, (void*)1);

    pthread_create(&tid, NULL, thread_routine, (void*)1);

    pthread_create(&tid, NULL, thread_routine, (void*)1);

    pthread_create(&tid, NULL, thread_routine, (void*)1);

    pthread_create(&tid, NULL, thread_routine, (void*)1);

    pthread_create(&tid, NULL, thread_routine, (void*)1);

    pthread_create(&tid, NULL, thread_routine, (void*)0);

    pthread_create(&tid, NULL, thread_routine, (void*)0);

    getchar();

    return 0;

}

so true 2018-05-14 12:07 发表评论

#include <signal.h>

#include <stdlib.h>

#include <fcntl.h>

#include <unistd.h>

#include <sys/stat.h>

void daemonize() {

    int pid = -1, fd = -1;

    // 1.转变为后台进程

    if ((pid = fork()) == -1) exit(1);

    if (pid != 0) exit(0); // 父进程（前台进程）退出

    // 2.离开原先的进程组，会话

    if (setsid() == -1) exit(1); // 开启一个新会话

    // 3.禁止再次打开控制终端

    if ((pid = fork()) == -1) exit(1);

    if (pid != 0) exit(0); // 父进程（会话领头进程）退出

    // 4.关闭打开的文件描述符，避免浪费系统资源

    for (int i = 0; i < NOFILE; i++)

        close(i);

    // 5.改变当前的工作目录，避免卸载不了文件系统

    if (chdir("/") == -1) exit(1);

    // 6.重设文件掩码，防止某些属性被父进程屏蔽，也有设置为0027的（守护进程创建的临时文件不希望被其他用户查看）

    umask(0);

    // 7.重定向标准输入，输出，错误流，因为守护进程没有控制终端

    // 如果只是把0、1、2都close了，那么守护进程里新创建的文件fd会用到0、1、2，如果用户的代码里有用到printf/cout之类的，那就会把数据打到新创建的文件中，这样就会产生混淆

    if ((fd = open("/dev/null", O_RDWR)) == -1) exit(1); // 打开一个指向/dev/null的文件描述符

    dup2(fd, STDIN_FILENO);

    dup2(fd, STDOUT_FILENO);

    dup2(fd, STDERR_FILENO);

    close(fd);

    // 8.本守护进程的子进程若不需要返回信息，那么交给init进程回收，避免产生僵尸进程，否则子进程退出后将成为僵尸进程

    if (signal(SIGCHLD, SIG_IGN) == SIG_ERR) exit(1);

}

so true 2018-04-12 18:36 发表评论

        int pivot = i++;

        while (true) {

            while (i <= j && nums[i] <= nums[pivot]) ++i; //a

            while (j >= i && nums[j] >= nums[pivot]) --j; //b

            if (i > j) {

                break;

            }

            int t = nums[i]; nums[i++] = nums[j]; nums[j--] = t; //c

        }

        int t = nums[j]; nums[j] = nums[pivot]; nums[pivot] = t;

        return j;

    }
上面这段代码里，细节太多太多，居然搞了一晚上才搞出来，总的来说大方向上：
1. 要确保最后能i > j才能终止（其实终止的时候，是一定满足j + 1 == i的）；
2. 因为保留的是最左侧的数为基准，排序目标是从左到右按照从小到大排，因此最后要把pivot和j交换；
3. //a和//b里，其实只要有一个nums[i]/nums[j]和nums[pivot]的等于判断就可以了，这里为了一致性，都保留了对等于的判断；
4. //c里增加了i和j各自挪一步的操作，因此如下写法更好：

so true 2017-11-26 00:03 发表评论

  1 #include <sys/time.h>
  2 #include <stdlib.h>
  3 #include <string.h>
  4 #include <iostream>
  5 #include <vector>
  6 #include <string>
  7 #include <set>
  8 
  9 class Sudoku {
 10 public:
 11     Sudoku(const std::string& question, bool does_try_all_answers = false): m_does_try_all_answers(does_try_all_answers), m_data(9) {
 12         for (int i = 0; i < 9; ++i) {
 13             m_data[i].resize(9);
 14             for (int j = 0; j < 9; ++j) {
 15                 m_data[i][j] = question[i * 9 + j];
 16             }
 17         }
 18     }
 19 
 20     bool Solve() {
 21         return Fill(0, 0);
 22     }
 23 
 24     const std::string GiveOneAnswer() const {
 25         return m_all_answers.empty() ? "" : *m_all_answers.begin();
 26     }
 27 
 28     const std::set<std::string> GiveAllAnswers() const {
 29         return m_all_answers;
 30     }
 31 
 32     static const std::string ProvideOneQuestionRandomly(int min_filled_num = 30) {
 33         std::vector<std::vector<char> > ques(9, std::vector<char>(9, '.'));
 34 
 35         struct timeval cur_tv;
 36         gettimeofday(&cur_tv, NULL);
 37         srand(cur_tv.tv_usec);
 38 
 39         int valid_digit_num = 0;
 40         for (int i = 0; i < 9; ++i) {
 41             for (int j = 0; j < 9; ++j) {
 42                 if (rand() % 81 <= min_filled_num + valid_digit_num / 6) {
 43                     char c = rand() % 9 + '1';
 44 
 45                     if (DoesConflict(ques, i, j, c)) {
 46                         int k = 0;
 47                         for (; k < 8; ++k) {
 48                             if (c == '9') {
 49                                 c = '1';
 50                             }
 51                             if (!DoesConflict(ques, i, j, ++c)) {
 52                                 break;
 53                             }
 54                         }
 55                         if (8 == k) {
 56                             c = '.';
 57                         }
 58                     }
 59 
 60                     valid_digit_num += ('.' != c);
 61                     ques[i][j] = c;
 62                 } else {
 63                     ques[i][j] = '.';
 64                 }
 65             }
 66         }
 67 
 68         char buf[82];
 69         buf[81] = '\0';
 70         for (int i = 0; i < 9; ++i) {
 71             for (int j = 0; j < 9; ++j) {
 72                 buf[i * 9 + j] = ques[i][j];
 73             }
 74         }
 75 
 76         Sudoku sudoku(buf);
 77         sudoku.Solve();
 78         if (81 == sudoku.GiveOneAnswer().size()) {
 79             return buf;
 80         } else {
 81             return ProvideOneQuestionRandomly(min_filled_num);
 82         }
 83 
 84         return buf;
 85     }
 86 
 87     static void PrintSudoku(const std::string& sudoku) {
 88         if (sudoku.size() < 81) {
 89             return;
 90         }
 91 
 92         for (int i = 0; i < 9; ++i) {
 93             for (int j = 0; j < 9; ++j) {
 94                 if (0 != j) {
 95                     std::cout << " ";
 96                 }
 97                 std::cout << sudoku[i * 9 + j];
 98             }
 99             std::cout << std::endl;
100         }
101     }
102 
103     static bool ValidateOneAnswer(const std::string& answer) {
104         if (answer.size() != 81) {
105             return false;
106         }
107 
108         for (int i = 0; i < 9; ++i) {
109             char hit_h[9] = { '\0' };
110             char hit_v[9] = { '\0' };
111             for (int j = 0; j < 9; ++j) {
112                 if ('.' == answer[i * 9 + j] || ++hit_h[answer[i * 9 + j] - '1'] != 1) { //row check
113                     return false;
114                 } else if ('.' == answer[j * 9 + i] || ++hit_v[answer[j * 9 + i] - '1'] != 1) { //column check
115                     return false;
116                 }
117                 if (0 == i % 3 && 0 == j % 3) { //3x3 square check
118                     char hit_m[9] = { '\0' };
119                     for (int i2 = i; i2 < i + 3; ++i2) {
120                         for (int j2 = j; j2 < j + 3; ++j2) {
121                             if ('.' == answer[i2 * 9 + j2] || ++hit_m[answer[i2 * 9 + j2] - '1'] != 1) {
122                                 return false;
123                             }
124                         }
125                     }
126                 }
127             }
128         }
129         return true;
130     }
131 
132 private:
133     void AddOneAnswer() {
134         char buf[82];
135         buf[81] = '\0';
136 
137         for (int i = 0; i < 9; ++i) {
138             for (int j = 0; j < 9; ++j) {
139                 buf[i * 9 + j] = m_data[i][j];
140             }
141         }
142 
143         m_all_answers.insert(buf);
144     }
145 
146     static bool DoesConflict(const std::vector<std::vector<char> >& data, int i, int j, char digit) {
147         for (int k = 0; k < 9; ++k) {
148             if (digit == data[i][k]) {
149                 return true;
150             }
151             if (digit == data[k][j]) {
152                 return true;
153             }
154         }
155 
156         int i0 = i - i % 3;
157         int j0 = j - j % 3;
158         for (int i2 = i0; i2 < i0 + 3; ++i2) {
159             for (int j2 = j0; j2 < j0 + 3; ++j2) {
160                 if (digit == data[i2][j2]) {
161                     return true;
162                 }
163             }
164         }
165 
166         return false;
167     }
168 
169     bool Fill(int i, int j) {
170         for (; i < 9; ++i, j = 0) {
171             for (; j < 9; ++j) {
172                 if ('.' == m_data[i][j]) {
173                     for (int k = '1'; k <= '9'; ++k) {
174                         if (DoesConflict(m_data, i, j, k)) {
175                             continue;
176                         }
177 
178                         m_data[i][j] = k;
179                         if (8 == j) {
180                             if (Fill(i + 1, 0)) {
181                                 AddOneAnswer();
182                                 if (!m_does_try_all_answers) {
183                                     return true;
184                                 }
185                             }
186                         } else {
187                             if (Fill(i, j + 1)) {
188                                 AddOneAnswer();
189                                 if (!m_does_try_all_answers) {
190                                     return true;
191                                 }
192                             }
193                         }
194                     }
195                     m_data[i][j] = '.';
196                     return false;
197                 }
198             }
199         }
200 
201         AddOneAnswer();
202         return true;
203     }
204 
205 private:
206     bool m_does_try_all_answers;
207     std::vector<std::vector<char> > m_data;
208     std::set<std::string> m_all_answers;
209 };
210 
211 int main(int argc, char* argv[]) {
212     std::string question;
213     //with many answers
214     question = ".2..4836..5163887..63195..45.4.7.2.98..";
215 
216     //with just one answer: https://baike.baidu.com/item/%E4%B8%96%E7%95%8C%E6%9C%80%E9%9A%BE%E6%95%B0%E7%8B%AC/13848819
217     question = "..53..82..7..1.5..4.531..76..328..6.5.9..4.397..";
218 
219     bool find_all_answers = false;
220     if (argc > 1 && 81 == strlen(argv[1])) {
221         question = argv[1];
222     } else {
223         if (argc > 1) {
224             find_all_answers = true;
225         }
226         question = Sudoku::ProvideOneQuestionRandomly();
227     }
228 
229     Sudoku::PrintSudoku(question);
230 
231     Sudoku sudoku(question, find_all_answers);
232     sudoku.Solve();
233 
234     const std::set<std::string>& all_answers = sudoku.GiveAllAnswers();
235     int idx = 0;
236     for (typeof(all_answers.begin()) iter = all_answers.begin(); all_answers.end() != iter; ++iter) {
237         std::cout << "answer " << ++idx << " for this sudoku is:" << std::endl;
238         Sudoku::PrintSudoku(*iter);
239         if (!Sudoku::ValidateOneAnswer(*iter)) {
240             std::cout << "answer is not correct: " << *iter << std::endl;
241         }
242         std::cout << "[" << *iter << "]" << std::endl;
243     }
244     return 0;
245 }
246 

so true 2017-11-03 17:19 发表评论

内核文档： Documentation/vm/pagemap.txt

pagemap is a new (as of 2.6.25) set of interfaces in the kernel that allow

userspace programs to examine the page tables and related information by

reading files in /proc.

There are four components to pagemap:

 * /proc/pid/pagemap.  This file lets a userspace process find out which

   physical frame each virtual page is mapped to.  It contains one 64-bit

   value for each virtual page, containing the following data (from

   fs/proc/task_mmu.c, above pagemap_read):

    * Bits 0-54  page frame number (PFN) if present

    * Bits 0-4   swap type if swapped

    * Bits 5-54  swap offset if swapped

    * Bit  55    pte is soft-dirty (see Documentation/vm/soft-dirty.txt)

    * Bit  56    page exclusively mapped (since 4.2)

    * Bits 57-60 zero

    * Bit  61    page is file-page or shared-anon (since 3.5)

    * Bit  62    page swapped

    * Bit  63    page present

   Since Linux 4.0 only users with the CAP_SYS_ADMIN capability can get PFNs.

   In 4.0 and 4.1 opens by unprivileged fail with -EPERM.  Starting from

   4.2 the PFN field is zeroed if the user does not have CAP_SYS_ADMIN.

   Reason: information about PFNs helps in exploiting Rowhammer vulnerability.

   If the page is not present but in swap, then the PFN contains an

   encoding of the swap file number and the page's offset into the

   swap. Unmapped pages return a null PFN. This allows determining

   precisely which pages are mapped (or in swap) and comparing mapped

   pages between processes.

   Efficient users of this interface will use /proc/pid/maps to

   determine which areas of memory are actually mapped and llseek to

   skip over unmapped regions.

 下面是一个工具：

 1 #include <stdio.h>

 2 #include <stdlib.h>

 3 #include <unistd.h>

 4 #include <assert.h>

 5 #include <errno.h>

 6 #include <stdint.h>

 7 #include <string.h>

 8 

 9 #define PAGEMAP_ENTRY 8

10 #define GET_BIT(X,Y) (X & ((uint64_t)1<<Y)) >> Y

11 #define GET_PFN(X) X & 0x7FFFFFFFFFFFFF

12 

13 const int __endian_bit = 1;

14 #define is_bigendian() ( (*(char*)&__endian_bit) == 0 )

15 

16 int i, c, pid, status;

17 unsigned long virt_addr; 

18 uint64_t read_val, file_offset, page_size;

19 char path_buf [0x100] = {};

20 FILE * f;

21 char *end;

22 

23 int read_pagemap(char * path_buf, unsigned long virt_addr);

24 

25 int main(int argc, char ** argv){

26     if(argc!=3){

27         printf("Argument number is not correct!\n pagemap PID VIRTUAL_ADDRESS\n");

28         return -1;

29     }

30     if(!memcmp(argv[1],"self",sizeof("self"))){

31         sprintf(path_buf, "/proc/self/pagemap");

32         pid = -1;

33     }

34     else{

35         pid = strtol(argv[1],&end, 10);

36         if (end == argv[1] || *end != '\0' || pid<=0){ 

37             printf("PID must be a positive number or 'self'\n");

38             return -1;

39         }

40     }

41     virt_addr = strtoll(argv[2], NULL, 16);

42     if(pid!=-1)

43         sprintf(path_buf, "/proc/%u/pagemap", pid);

44 

45     page_size = getpagesize();

46     read_pagemap(path_buf, virt_addr);

47     return 0;

48 }

49 

50 int read_pagemap(char * path_buf, unsigned long virt_addr){

51     printf("Big endian? %d\n", is_bigendian());

52     f = fopen(path_buf, "rb");

53     if(!f){

54         printf("Error! Cannot open %s\n", path_buf);

55         return -1;

56     }

57 

58     //Shifting by virt-addr-offset number of bytes

59     //and multiplying by the size of an address (the size of an entry in pagemap file)

60     file_offset = virt_addr / page_size * PAGEMAP_ENTRY;

61     printf("Vaddr: 0x%lx, Page_size: %lld, Entry_size: %d\n", virt_addr, page_size, PAGEMAP_ENTRY);

62     printf("Reading %s at 0x%llx\n", path_buf, (unsigned long long) file_offset);

63     status = fseek(f, file_offset, SEEK_SET);

64     if(status){

65         perror("Failed to do fseek!");

66         return -1;

67     }

68     errno = 0;

69     read_val = 0;

70     unsigned char c_buf[PAGEMAP_ENTRY];

71     for(i=0; i < PAGEMAP_ENTRY; i++){

72         c = getc(f);

73         if(c==EOF){

74             printf("\nReached end of the file\n");

75             return 0;

76         }

77         if(is_bigendian())

78             c_buf[i] = c;

79         else

80             c_buf[PAGEMAP_ENTRY - i - 1] = c;

81         printf("[%d]0x%x ", i, c);

82     }

83     for(i=0; i < PAGEMAP_ENTRY; i++){

84         //printf("%d ",c_buf[i]);

85         read_val = (read_val << 8) + c_buf[i];

86     }

87     printf("\n");

88     printf("Result: 0x%llx\n", (unsigned long long) read_val);

89     if(GET_BIT(read_val, 63)) {

90         uint64_t pfn = GET_PFN(read_val);

91         printf("PFN: 0x%llx (0x%llx)\n", pfn, pfn * page_size + virt_addr % page_size);

92     } else

93         printf("Page not present\n");

94     if(GET_BIT(read_val, 62))

95         printf("Page swapped\n");

96     fclose(f);

97     return 0;

98 }

测试：

用Qemu+vexpress-ca9：

内存： 1GB， 物理地址范围： 0x60000000->0x9FFFFFFF

通过查看/proc/pid/maps获得进程的地址空间的内存映射情况：

 1 [root@vexpress ~]# cat /proc/746/maps 

 2 00008000-001f3000 r-xp 00000000 b3:01 62         /bin/busybox

 3 001fa000-001fc000 rw-p 001ea000 b3:01 62         /bin/busybox

 4 001fc000-00222000 rw-p 00000000 00:00 0          [heap]

 5 b6c7f000-b6c80000 rw-p 00000000 00:00 0 

 6 b6c80000-b6c8d000 r-xp 00000000 b3:01 174        /lib/libnss_files-2.18.so

 7 b6c8d000-b6c94000 ---p 0000d000 b3:01 174        /lib/libnss_files-2.18.so

 8 b6c94000-b6c95000 r--p 0000c000 b3:01 174        /lib/libnss_files-2.18.so

 9 b6c95000-b6c96000 rw-p 0000d000 b3:01 174        /lib/libnss_files-2.18.so

10 b6c96000-b6ca1000 r-xp 00000000 b3:01 141        /lib/libnss_nis-2.18.so

11 b6ca1000-b6ca8000 ---p 0000b000 b3:01 141        /lib/libnss_nis-2.18.so

12 b6ca8000-b6ca9000 r--p 0000a000 b3:01 141        /lib/libnss_nis-2.18.so

13 b6ca9000-b6caa000 rw-p 0000b000 b3:01 141        /lib/libnss_nis-2.18.so

14 b6caa000-b6daa000 rw-p 00000000 00:00 0 

15 b6daa000-b6dca000 r-xp 00000000 b3:01 129        /lib/ld-2.18.so

16 b6dca000-b6dd1000 ---p 00020000 b3:01 129        /lib/ld-2.18.so

17 b6dd1000-b6dd2000 r--p 0001f000 b3:01 129        /lib/ld-2.18.so

18 b6dd2000-b6dd3000 rw-p 00020000 b3:01 129        /lib/ld-2.18.so

19 b6dd3000-b6f06000 r-xp 00000000 b3:01 170        /lib/libc-2.18.so

20 b6f06000-b6f0d000 ---p 00133000 b3:01 170        /lib/libc-2.18.so

21 b6f0d000-b6f0f000 r--p 00132000 b3:01 170        /lib/libc-2.18.so

22 b6f0f000-b6f10000 rw-p 00134000 b3:01 170        /lib/libc-2.18.so

23 b6f10000-b6f13000 rw-p 00000000 00:00 0 

24 b6f13000-b6f26000 r-xp 00000000 b3:01 177        /lib/libnsl-2.18.so

25 b6f26000-b6f2d000 ---p 00013000 b3:01 177        /lib/libnsl-2.18.so

26 b6f2d000-b6f2e000 r--p 00012000 b3:01 177        /lib/libnsl-2.18.so

27 b6f2e000-b6f2f000 rw-p 00013000 b3:01 177        /lib/libnsl-2.18.so

28 b6f2f000-b6f31000 rw-p 00000000 00:00 0 

29 b6f31000-b6f39000 r-xp 00000000 b3:01 154        /lib/libnss_compat-2.18.so

30 b6f39000-b6f40000 ---p 00008000 b3:01 154        /lib/libnss_compat-2.18.so

31 b6f40000-b6f41000 r--p 00007000 b3:01 154        /lib/libnss_compat-2.18.so

32 b6f41000-b6f42000 rw-p 00008000 b3:01 154        /lib/libnss_compat-2.18.so

33 be958000-be979000 rw-p 00000000 00:00 0          [stack]

34 bed04000-bed05000 r-xp 00000000 00:00 0          [sigpage]

35 bed05000-bed06000 r--p 00000000 00:00 0          [vvar]

36 bed06000-bed07000 r-xp 00000000 00:00 0          [vdso]

37 ffff0000-ffff1000 r-xp 00000000 00:00 0          [vectors]

可以看看0x8000这个虚拟地址对应的物理地址：

1 [root@vexpress ~]# ./translate 746 0x8000

2 Big endian? 0

3 Vaddr: 0x8000, Page_size: 4096, Entry_size: 8

4 Reading /proc/746/pagemap at 0x40

5 [0]0x0 [1]0xf8 [2]0x9 [3]0x0 [4]0x0 [5]0x0 [6]0x0 [7]0xa0 

6 Result: 0xa00000000009f800

7 PFN: 0x9f800 (0x9f800000)

可以看到， 对应的物理页帧是0x9F800，那么物理地址就是0x9F800000.

下面我们再做一个实验， 进程746的地址空间有一部分用来映射libc：

1 b6dd3000-b6f06000 r-xp 00000000 b3:01 170        /lib/libc-2.18.so

2 b6f06000-b6f0d000 ---p 00133000 b3:01 170        /lib/libc-2.18.so

3 b6f0d000-b6f0f000 r--p 00132000 b3:01 170        /lib/libc-2.18.so

4 b6f0f000-b6f10000 rw-p 00134000 b3:01 170        /lib/libc-2.18.so

此外， 进程835也会用到libc：

1 [root@vexpress ~]# cat /proc/835/maps 

2 ... ...

3 b6e0b000-b6f3e000 r-xp 00000000 b3:01 170        /lib/libc-2.18.so

4 b6f3e000-b6f45000 ---p 00133000 b3:01 170        /lib/libc-2.18.so

5 b6f45000-b6f47000 r--p 00132000 b3:01 170        /lib/libc-2.18.so

6 b6f47000-b6f48000 rw-p 00134000 b3:01 170        /lib/libc-2.18.so

7 ... ...

可以看到， 进程746和835虽然都用了libc，但是对应的虚拟地址却不同，前者是0xb6dd3000， 而后者是0xb6e0b000, 我们知道对于共享库， 在内存只会存在一份代码， 那么物理地址也就是唯一的（代码段是唯一的，所有调用libc的进程共享，而数据段每个进程一个）， 那么进程746的虚拟地址空间的0xb6dd3000（代码段）跟进程835的虚拟地址空间的0xb6e0b000（代码段）对应的物理地址应该是同一个， 下面验证一下：

进程746：

1 [root@vexpress ~]# ./translate 746 0xb6dd3000

2 virt_addr: 0xb6dd3000

3 Big endian? 0

4 Vaddr: 0xb6dd3000, Page_size: 4096, Entry_size: 8

5 Reading /proc/746/pagemap at 0x5b6e98

6 [0]0x68 [1]0xfa [2]0x9 [3]0x0 [4]0x0 [5]0x0 [6]0x0 [7]0xa0 

7 Result: 0xa00000000009fa68

8 PFN: 0x9fa68 (0x9fa68000)

可以看到，物理地址是0x9FA68000

进程835：

1 [root@vexpress ~]# ./translate 835 0xb6e0b000

2 virt_addr: 0xb6e0b000

3 Big endian? 0

4 Vaddr: 0xb6e0b000, Page_size: 4096, Entry_size: 8

5 Reading /proc/835/pagemap at 0x5b7058

6 [0]0x68 [1]0xfa [2]0x9 [3]0x0 [4]0x0 [5]0x0 [6]0x0 [7]0xa0 

7 Result: 0xa00000000009fa68

8 PFN: 0x9fa68 (0x9fa68000)

可以看到， 物理地址也是0x9FA68000， 从而证明了我们的猜想。
=========================================================================

so true 2017-08-17 17:33 发表评论

so true 2017-07-25 20:19 发表评论

#include <string>

#include <vector>

#include <map>

#include <set>

using namespace std;

//part 1

class A {

private:

    A() {};

public:

    static A* GetInstance() {

        return new A();

    }

};

//part 2

class A {

    friend class B;

private:

    A() {};

};

class B: public A {

};

//part 3

class A {

    friend class B;

private:

    A() {};

};

class B: virtual public A {

};

//part 4: 奇异递归模板模式（curiously recurring template pattern，CRTP）

template <typename T>

class A {

    friend T;

private:

    A() {};

};

class B: virtual public A<B> {

};

//part 4.2:

//这种技术获得了类似于虚函数的效果，并避免了动态多态的代价。也有人把CRTP称为“模拟的动态绑定”

template <typename T>

struct counter

{

    static int objects_created;

    static int objects_alive;

    counter()

    {

        ++objects_created;

        ++objects_alive;

    }

    

    counter(const counter&)

    {

        ++objects_created;

        ++objects_alive;

    }

protected:

    ~counter() // objects should never be removed through pointers of this type

    {

        --objects_alive;

    }

};

template <typename T> int counter<T>::objects_created( 0 );

template <typename T> int counter<T>::objects_alive( 0 );

class X : counter<X>

{

    ...

};

    

class Y : counter<Y>

{

     ...

};

//part 5

class A {

protected:

    A() {};

};

class B: virtual A {

};

//part 6

class B final {

};

//validate

class C: public B {

};

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

    B b;

    C c;

    return 0;

}

so true 2017-07-17 19:31 发表评论

#ulimit -c unlimited

export PS4='+{$LINENO($(date +"%F %T")):${FUNCNAME[0]}} '

full_path=$(readlink -f $0)

#cd $(dirname $full_path)

#exec 1>${full_path%.*}.log

exec 2>${full_path%.*}.err

set -x

usage() {

    printf \

"Usage: %s <pid|pid_file> <start_cmd|start_script>\n\n \

 pid|pid_file                 process pid or the pid file containing the pid of process to be supervised\n \

 start_cmd|start_script       start commands or start script if process dead\n \

\n" $1

    exit 1

}

if [ $# -lt 2 ]; then

    usage $0

fi

pid_way=$1

if [ "" != "${pid_way//[0-9]}" -a -s "$pid_way" ]; then

    pid_file=$(readlink -f $pid_way)

else

    pid_id=$pid_way

    pinfo=($(ps -eo uid,pid,args | awk -v pid=$pid_id '{if($2==pid)print $0}'))

    puid=${pinfo[0]}

    pname=${pinfo[2]}

    if [ "" == "$puid" -o "" == "$pname" ]; then

        echo "Couldn't find the process with the pid $pid_id"

        exit 2

    fi

fi

cmd=($2)

if [ -s "${cmd[0]}" ]; then

    start_way=$(readlink -f ${cmd[0]})

    for ((i=1; i<${#cmd[@]}; ++i)); do

        start_way="$start_way ""${cmd[$i]}"

    done

    shift 2

    start_way="$start_way ""$@"

else

    shift 1

    start_way="$@"

fi

while true; do

    if [ "" != "$pid_id" ]; then

        pid=$pid_id

    else

        pid=$(cat $pid_file)

    fi

    if [ "" != "$pid" ]; then

        if ! kill -0 $pid; then

            now=$(date +%s)

            $start_way            

            #sleep 60

            if [ "" != "$pid_id" ]; then

                tm_fields_num=$(ps -eo lstart | tail -1 | awk '{print NF}')

                find_new_process=0

                pid_id_bak=()

                while read line; do

                    pstarttime=$(date -d "${line#* }" +%s) 

                    if [ "$pstarttime" -ge "$now" ]; then

                        pid_id_tmp=${line%% *}

                        pinfo_new=($(ps -eo uid,pid,args | awk -v pid=$pid_id_tmp '{if($2==pid)print $0}'))

                        if [ "0" == "${#pinfo_new[@]}" ]; then

                            continue

                        fi

                        diff_fields_num=0

                        for ((i=3; i<(${#pinfo[@]} > ${#pinfo_new[@]} ? ${#pinfo[@]} : ${#pinfo_new[@]}); ++i)); do

                            if [ "${pinfo[$i]}" != "${pinfo_new[$i]}" ]; then

                                ((++diff_fields_num))

                            fi

                        done

                        if [ "0" -eq "$diff_fields_num" ]; then

                            pid_id=$pid_id_tmp

                            if [ "$((++find_new_process))" -gt "1" ]; then

                                exit 1

                            fi

                        else

                            pid_id_bak[$diff_fields_num]=$pid_id_tmp

                        fi

                    fi

                done < <(ps -eo uid,pid,lstart,args | awk -v puid=$puid -v pname=$pname -v tfn=$tm_fields_num '{if($1==puid && $(3+tfn)==pname){printf "%d ", $2; for(i=3;i<3+tfn;++i) printf "%s ", $i; printf "\n";}}')

                if [ "0" == "$find_new_process" ]; then

                    pid_id=${pid_id_bak[@]}

                    pid_id=${pid_id%% *}

                fi

            else

                tm_new_pid_file=$(date -d "$(stat $pid_file | grep ^Modify: | sed 's#Modify:##')" +%s)

                if [ "$tm_new_pid_file" -lt "$now" ]; then

                    exit 2

                fi

            fi

        fi

    fi

    #sleep 1

    if [ "$(ls -l ${full_path%.*}.err | awk '{print $5}')" -ge $((1024 * 1024 * 1024)) ]; then

        set +x

        exec 2>/dev/null

        cp ${full_path%.*}.err ${full_path%.*}.err.last

        rm -f ${full_path%.*}.err

        exec 2>${full_path%.*}.err

        set -x

    fi

done

so true 2017-04-06 16:00 发表评论

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <netdb.h>

#include <unistd.h>

#include <fcntl.h>

#include <sys/epoll.h>

#include <errno.h>

#define MAXEVENTS 64

static int make_socket_non_blocking(int sfd) {

    int flags, s;

    flags = fcntl(sfd, F_GETFL, 0);

    if (flags == -1) {

        perror("fcntl");

        return -1;

    }

    flags |= O_NONBLOCK;

    s = fcntl(sfd, F_SETFL, flags);

    if (s == -1) {

        perror("fcntl");

        return -1;

    }

    return 0;

}

static int create_and_bind(char *port) {

    struct addrinfo hints;

    struct addrinfo *result, *rp;

    int s, sfd;

    memset(&hints, 0, sizeof(struct addrinfo));

    hints.ai_family = AF_UNSPEC; /* Return IPv4 and IPv6 choices */

    hints.ai_socktype = SOCK_STREAM; /* We want a TCP socket */

    hints.ai_flags = AI_PASSIVE; /* All interfaces */

    s = getaddrinfo(NULL, port, &hints, &result);

    if (s != 0) {

        fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(s));

        return -1;

    }

    for (rp = result; rp != NULL; rp = rp->ai_next) {

        sfd = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);

        if (sfd == -1)

            continue;

        s = bind(sfd, rp->ai_addr, rp->ai_addrlen);

        if (s == 0) {

            /* We managed to bind successfully! */

            break;

        }

        close(sfd);

    }

    if (rp == NULL) {

        fprintf(stderr, "Could not bind\n");

        return -1;

    }

    freeaddrinfo(result);

    return sfd;

}

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

    int sfd, s;

    int efd;

    struct epoll_event event;

    struct epoll_event *events;

    if (argc != 2) {

        fprintf(stderr, "Usage: %s [port]\n", argv[0]);

        exit(EXIT_FAILURE);

    }

    sfd = create_and_bind(argv[1]);

    if (sfd == -1)

        abort();

    s = make_socket_non_blocking(sfd);

    if (s == -1)

        abort();

    s = listen(sfd, SOMAXCONN);

    if (s == -1) {

        perror("listen");

        abort();

    }

    efd = epoll_create1(0);

    if (efd == -1) {

        perror("epoll_create");

        abort();

    }

    event.data.fd = sfd;

    event.events = EPOLLIN | EPOLLET;

    s = epoll_ctl(efd, EPOLL_CTL_ADD, sfd, &event);

    if (s == -1) {

        perror("epoll_ctl");

        abort();

    }

    /* Buffer where events are returned */

    events = calloc(MAXEVENTS, sizeof event);

    /* The event loop */

    while (1) {

        int n, i;

        n = epoll_wait(efd, events, MAXEVENTS, -1);

        for (i = 0; i < n; i++) {

            if ((events[i].events & EPOLLERR) || (events[i].events & EPOLLHUP) || (!(events[i].events & EPOLLIN))) {

                /* An error has occured on this fd, or the socket is not

                 ready for reading (why were we notified then?) */

                fprintf(stderr, "epoll error\n");

                close(events[i].data.fd);

                continue;

            }

            else if (sfd == events[i].data.fd) {

                /* We have a notification on the listening socket, which

                 means one or more incoming connections. */

                while (1) {

                    struct sockaddr in_addr;

                    socklen_t in_len;

                    int infd;

                    char hbuf[NI_MAXHOST], sbuf[NI_MAXSERV];

                    in_len = sizeof in_addr;

                    infd = accept(sfd, &in_addr, &in_len);

                    if (infd == -1) {

                        if ((errno == EAGAIN) || (errno == EWOULDBLOCK)) {

                            /* We have processed all incoming

                             connections. */

                            break;

                        } else {

                            perror("accept");

                            break;

                        }

                    }

                    s = getnameinfo(&in_addr, in_len, hbuf, sizeof hbuf, sbuf, sizeof sbuf, NI_NUMERICHOST | NI_NUMERICSERV);

                    if (s == 0) {

                        printf("Accepted connection on descriptor %d "

                            "(host=%s, port=%s)\n", infd, hbuf, sbuf);

                    }

                    /* Make the incoming socket non-blocking and add it to the

                     list of fds to monitor. */

                    s = make_socket_non_blocking(infd);

                    if (s == -1)

                        abort();

                    event.data.fd = infd;

                    event.events = EPOLLIN | EPOLLET;

                    s = epoll_ctl(efd, EPOLL_CTL_ADD, infd, &event);

                    if (s == -1) {

                        perror("epoll_ctl");

                        abort();

                    }

                }

                continue;

            } else {

                /* We have data on the fd waiting to be read. Read and

                 display it. We must read whatever data is available

                 completely, as we are running in edge-triggered mode

                 and won't get a notification again for the same

                 data. */

                int done = 0;

                while (1) {

                    ssize_t count;

                    char buf[512];

                    count = read(events[i].data.fd, buf, sizeof buf);

                    if (count == -1) {

                        /* If errno == EAGAIN, that means we have read all

                         data. So go back to the main loop. */

                        if (errno != EAGAIN) {

                            perror("read");

                            done = 1;

                        }

                        break;

                    } else if (count == 0) {

                        /* End of file. The remote has closed the

                         connection. */

                        done = 1;

                        break;

                    }

                    /* Write the buffer to standard output */

                    s = write(1, buf, count);

                    if (s == -1) {

                        perror("write");

                        abort();

                    }

                }

                if (done) {

                    printf("Closed connection on descriptor %d\n", events[i].data.fd);

                    /* Closing the descriptor will make epoll remove it

                     from the set of descriptors which are monitored. */

                    close(events[i].data.fd);

                }

            }

        }

    }

    free(events);

    close(sfd);

    return EXIT_SUCCESS;

}

so true 2016-06-22 17:23 发表评论

1. get the PID (say $pid) of the program by adding the -p option to netstat.

2. identify the proper line in the /proc/net/tcp file by looking at the local_address and/or rem_address fields (note that they are in hex format, specifically the IP address is expressed in little-endian byte order), also make sure that the st is 01 (for ESTABLISHED);

3. note the associated inode field (say $inode);

4. search for that inode among the file descriptors in /proc/$pid/fd and finally query the file access time of the symbolic link: find /proc/$pid/fd -lname "socket:\[$inode\]" -printf %t

function suptime() {

    local addr=${1:?Specify the remote IPv4 address}

    local port=${2:?Specify the remote port number}

    # convert the provided address to hex format

    local hex_addr=$(python -c "import socket, struct; print(hex(struct.unpack('<L', socket.inet_aton('$addr'))[0])[2:10].upper().zfill(8))")

    local hex_port=$(python -c "print(hex($port)[2:].upper().zfill(4))")

    # get the PID of the owner process

    local pid=$(netstat -ntp 2>/dev/null | awk '$6 == "ESTABLISHED" && $5 == "'$addr:$port'"{sub("/.*", "", $7); print $7}')

    [ -z "$pid" ] && { echo 'Address does not match' 2>&1; return 1; }

    # get the inode of the socket

    local inode=$(awk '$4 == "01" && $3 == "'$hex_addr:$hex_port'" {print $10}' /proc/net/tcp)

    [ -z "$inode" ] && { echo 'Cannot lookup the socket' 2>&1; return 1; }

    # query the inode status change time

    local timestamp=$(find /proc/$pid/fd -lname "socket:\[$inode\]" -printf %T@)

    [ -z "$timestamp" ] && { echo 'Cannot fetch the timestamp' 2>&1; return 1; }

    # compute the time difference

    LANG=C printf '%s (%.2fs ago)\n' "$(date -d @$timestamp)" $(bc <<<"$(date +%s.%N) - $timestamp")

}

#the function used to convert ip between hex and decimal style

so true 2016-06-15 11:59 发表评论

1。区别：

正向：A告诉C，我要明确访问B，C把B上的资源拽回来，返回给A；对B而言，访问我的是C，压根不知道A的存在；在A看来，我需要显示的配置代理服务器C，要明确告诉C我要访问的资源是B；

反向：A告诉C，我要请求一些资源，C知道资源在B上，从B上把资源拽回来返回给A；对B而言，直接访问我的是C但同时也知道真正的资源请求者是A；在A看来，压根不知道B的存在，一直以为资源就是在C上；

总结：正向非常简单理解，就是委托C帮我访问，出了事也都是C兜着，C这里仅仅是一个傻傻的替人干活和顶雷的工具，说白了就是A在本地wget拽B的资源不行，但在C上wget是可以拽下来B的资源的（当然这里C也得是一个server进程，因为要侦听端口等待A来访问，还要返回结果给A）；干反向代理的C不再是那么简单的一个工具了，而是一个真正意义上的service，可以综合考虑A的需求和B的服务能力来做智能转发，因此会具有负载均衡的能力（当然这里也可以使用最简化版的C，即：C也只是一股脑的单纯的把请求转发给B，在这种意义上，貌似感觉反向干的还是正向干的事，实则不然，关键在于B，对于正向而言B是一个特定的资源，例如B可以是https://www.zhihu.com/question/19761434，也可以是http://blog.csdn.net/physicsdandan/article/details/45667357；对于反向而言，B只能是一个或几个特定的服务地址，例如http://10.138.20.241:8834/，请求都是转给这一个或这几个特定服务地址的，当然这个特定服务地址也有可能又是proxy）

so true 2016-06-08 16:31 发表评论

理解:重定向这个概念其实不是很好理解，如果用编程里面的指针来说明，那就很容易了。举个例子，比如指针p1指向瓶子，指针p2指向抽屉，现在执行p1>&p2（相当于p1 = p2)，这样p1这个指针也指向抽屉了，也就是说我们把p1这个指针重定向到一个新的地方，这个地方是p2所指的地方，即抽屉；

    简而言之，这个例子里重定向的含义是：把p1指向p2所指的地方（重定向就是指向的含义），而瓶子、抽屉这2个“实体”是不变的，重定向能调整的只是指针的指向。

    $ ls -l /proc/$$/fd

    lr-x------ 1 admin admin 64 2016-03-30 10:14 0 -> /dev/pts/413

    lrwx------ 1 admin admin 64 2016-03-30 10:14 1 -> /dev/pts/413

    lrwx------ 1 admin admin 64 2016-03-30 10:14 2 -> /dev/pts/413

    lrwx------ 1 admin admin 64 2016-03-30 10:14 255 -> /dev/pts/413

    我们说0代表stdin，1代表stdout，2代表stderr，这里stdin/stdout/stderr是实体（这里都是/dev/pts/413，即terminal这个设备），0/1/2只是一个fd，可以理解为指针或者标记；

    (echo "I'm from stdout"; echo "I'm from stderr" 1>&2) 2>&1 >file1之所以file1里只会有1行，原因是：

    我们首先把2指向了stdout（stdout正是1所指的东西），这个时候1和2都指向了stdout；

    然后我们把1指向了file1，这个时候2依然还是指着stdout；

    然后I'm from stdout这句话写到了1里面，其实也就是写到了file1里面，I'm from stderr这句话写到了2里面，其实也就是写到了stdout里面。

整体规则:

    1. TO (<|>|<>) FROM;

    2. (<|>)这两个东西后面可以跟&fd/&-/&fd-，也可以跟一个file名字；例外>&file1表示stdout和stderr都重定向到file1里面；<>后面只可以跟file1，例如<>file1表示从file1里既读入数据，也写入数据;

    3. (<|>|<>)这三个东西前面不能有空格，后面跟的&不能有空格，除此之外无要求，例如：exec 1>& 2- #但2和-之间不能有空格；

操作:

    1. 打开一个fd的方法：exec fd>&1  或者   exec fd<&0 或者 exec fd>file1 或者 exec fd<file1 或者 exec fd <>file1；

       如果你不想指定fd（希望系统自动给你分配一个fd），那么有一种特殊的用法，例子是：

         exec {NEW_STDOUT}>&1 #注意这个用法很特殊，你不能NEW_STDOUT=15; exec ${NEW_STDOUT}>&1

         echo "hello" >&$NEW_STDOUT # echo "hello" >&${NEW_STDOUT}也可以

         echo ${NEW_STDOUT} #从10开始分配

         exec {NEW_STDOUT}>&-

    2. 关闭一个fd的方法：exec fd>&- 或者 exec fd<&-

    3. move fd的方法：new_fd>&old_fd-，move完之后，old_fd会被关掉；

实战:

    (echo "I'm from stdout"; echo "I'm from stderr" 1>&2) 2>&1 >file1 #file1里将会有1行I'm from stdout，原因是stdout赋给了stderr，file1赋给了stdout，2句话里，打印到stdout的那句被写入file1，打印到stderr被写入到了stdout

    (echo "I'm from stdout"; echo "I'm from stderr" 1>&2) >file1 2>&1 #file1里将会有2行，原因是file1赋给了stdout，stdout赋给了stderr（其实也就是file1赋给了stderr），这个时候，stdout和stderr都指向了file1

    (echo "I'm from stdout"; echo "I'm from stderr" 1>&2) &> file1 #file1里将会有2行，file1前面的空格可以省略

    (echo "I'm from stdout"; echo "I'm from stderr" 1>&2) >& file1 #file1里将会有2行，file1前面的空格可以省略

    (echo "I'm from stdout"; echo "I'm from stderr" 1>&2) |& cat > file1 #file1里将会有2行，file1前面的空格可以省略

    (echo "I'm from stdout"; echo "I'm from stderr" 1>&2) 2>&1 | cat > file1 #file1里将会有2行，file1前面的空格可以省略

    (echo "I'm from stdout"; echo "I'm from stderr" 1>&2) >file1 | grep err #grep fail

    (echo "I'm from stdout"; echo "I'm from stderr" 1>&2) 2>&1 >file1 | grep err #grep ok

    (echo "I'm from stdout"; echo "I'm from stderr" 1>&2) 3>&1 1>&2 2>&3-| grep stderr #grep ok，这其实实现了stdout和stderr的交换，类似于通过c=a;a=b;b=c;来实现a和b的交换（先把a赋给c，紧接着找到b赋给a，然后用c再赋给b）

    (echo "I'm from stdout"; echo "I'm from stderr" 1>&2) 1>&2- | grep stderr #grep ok

    echo "hello world" | tee >(grep hello) >(grep world) >/dev/null #结合上tee的多路dispatch，功能会更强大

    > file1 #create file1 or truncate file1 to zero size

    <file1 cat #<file1这部分放到命令的前面或者后面都可以

    2>&1 ls not_found_file | grep found #grep ok

    cat < file1 > file2 #等同于cp file1 file2

<>高级用法:

    1. 写到一个文件中指定的地方：

        echo 1234567890 > file1   # 写字符串到"File".

        exec 3<> file1            # 打开"File"并且给它分配fd 3.

        read -n 4 <&3             # 只读4个字符.

        echo -n . >&3             # 写一个小数点.

        exec 3>&-                 # 关闭fd 3.

        cat file1                 # ==> 1234.67890

    2. 用bash下载网页

        $ exec 3<>/dev/tcp/www.baidu.com/80

        $ echo -e "GET / HTTP/1.0\r\n\r\n" >&3

        $ cat <&3

        $ ls -l /proc/$$/fd

        total 0

        lr-x------ 1 admin admin 64 2016-03-30 10:14 0 -> /dev/pts/413

        lrwx------ 1 admin admin 64 2016-03-30 10:14 1 -> /dev/pts/413

        lrwx------ 1 admin admin 64 2016-03-30 10:14 2 -> /dev/pts/413

        lrwx------ 1 admin admin 64 2016-03-30 10:14 255 -> /dev/pts/413

        lrwx------ 1 admin admin 64 2016-03-30 10:14 3 -> socket:[173770096]

        $ exec 3>&- # exec 3<&-也可以关闭

so true 2016-03-30 12:10 发表评论

1。简单点用signal（主要就1个api，signal(SIGINT, SignalHandler)和signal(SIGINT, SIG_IGN)就是全部了）；

2。复杂点用sigaction（可以设置在handling期间，允许/不允许哪些信号打断自己）；

3。当前线程handling过程中，当前线程不会因为相同signal再次进入handler，但当前线程可以被别的signal打断重新进入handler，别的线程可以进入handler；

例如下面这个例子，只有一个主线程，先被SIGINT打断进入handler，虽然又被SIGTERM打断再次进入handler：

#0  0x00007f7cc55dc200 in __nanosleep_nocancel () at ../sysdeps/unix/syscall-template.S:82

#1  0x00007f7cc55dc090 in __sleep (seconds=<value optimized out>) at ../sysdeps/unix/sysv/linux/sleep.c:138

#2  0x0000000000468300 in SignalHandler (sig=15) at src/dispatcher2_server.cpp:78

#3  <signal handler called>

#4  0x00007f7cc55dc200 in __nanosleep_nocancel () at ../sysdeps/unix/syscall-template.S:82

#5  0x00007f7cc55dc090 in __sleep (seconds=<value optimized out>) at ../sysdeps/unix/sysv/linux/sleep.c:138

#6  0x0000000000468300 in SignalHandler (sig=2) at src/dispatcher2_server.cpp:78

#7  <signal handler called>

#8  0x00007f7cc55dc200 in __nanosleep_nocancel () at ../sysdeps/unix/syscall-template.S:82

#9  0x00007f7cc55dc090 in __sleep (seconds=<value optimized out>) at ../sysdeps/unix/sysv/linux/sleep.c:138

#10 0x000000000046844a in main (argc=1, argv=0x7fff048454a8) at src/dispatcher2_server.cpp:102

demo：

static void SignalHandler(int sig) {

    if (SIGTERM == sig || SIGINT == sig) {

        struct sigaction sa;

        memset(&sa, 0, sizeof(sa));

        sa.sa_handler = SIG_IGN;

        sigaction(SIGINT, &sa, NULL); // keep other threads from entering this handler

        sigaction(SIGTERM, &sa, NULL); // keep other threads from entering this handler

        

        //...

    }

}

struct sigaction sa;

memset(&sa, 0, sizeof(sa));

sa.sa_handler = SignalHandler;

sigfillset(&sa.sa_mask); // block every signal during handling

sigaction(SIGINT, &sa, NULL);

sigaction(SIGTERM, &sa, NULL);

介绍：http://www.alexonlinux.com/signal-handling-in-linux
demo：http://aspyct.org/blog/2012/08/25/unix-signal-handling-example/

so true 2016-02-17 11:30 发表评论

so true 2015-12-10 21:15 发表评论

so true 2015-08-08 07:30 发表评论

so true 2015-07-03 11:57 发表评论

so true 2015-03-12 20:50 发表评论

so true 2015-03-10 10:52 发表评论

#include <iostream>
#include <typeinfo>
#include <stdio.h>

using namespace std;

enum EM {ONE, TWO};

void func(int i) {
    cout << __PRETTY_FUNCTION__ << endl;
}

void func(EM i) {
    cout << __PRETTY_FUNCTION__ << endl;
}

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

template <typename T>
void trait(T t) {
    cout << __PRETTY_FUNCTION__ << endl;
}

template <typename R, typename C, typename Arg1>
void trait_detail(R (C::*class_member_pointer)(Arg1)) {
    cout << __PRETTY_FUNCTION__ << endl;
}

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

class A {
public:
    virtual void func() {
        cout << __PRETTY_FUNCTION__ << endl;
    }

    virtual A& reflect() {
        cout << __PRETTY_FUNCTION__ << endl;
        return *this;
    }
};

A* func_provide_local_class(int x = 0) {
    class LocalA: public A {
    public:
        LocalA(int x): m_x(x) {};
        virtual void func() {
            cout << __PRETTY_FUNCTION__ << endl;
        }

        virtual A& reflect() {
            return *this;
        }

    private:
        int m_x;
    };

    A* pa = new LocalA(x);
    cout << typeid(pa).name() << endl;
    return pa;
}

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

class B {
public:
    virtual int func(double& d) = 0;
};


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

int main(int argc, char* argv[]) {
    //enum is also a specific type
    EM em = ONE;
    func(argc);
    func(em);
    trait(em);
    printf("--------------------------------------------\n");

    //trait in two ways
    trait(&B::func);
    trait_detail(&B::func);
    printf("--------------------------------------------\n");

    //trial for local class, for more information see as http://www.geeksforgeeks.org/local-class-in-c/ and http://www.cppblog.com/mzty/archive/2007/05/24/24766.html
    A* pa = func_provide_local_class();
    pa->func();
    printf("--------------------------------------------\n");

    //there's no way to use local class externally
    trait(pa);
    trait(pa->reflect());
    printf("--------------------------------------------\n");

    return 0;
}

void func(int)

void func(EM)

void trait(T) [with T = EM]

--------------------------------------------

void trait(T) [with T = int (B::*)(double&)]

void trait_detail(R (C::*)(Arg1)) [with R = int, C = B, Arg1 = double&]

--------------------------------------------

P1A

virtual void func_provide_local_class(int)::LocalA::func()

--------------------------------------------

void trait(T) [with T = A*]

void trait(T) [with T = A]

--------------------------------------------

so true 2015-03-06 17:51 发表评论

#include <stdlib.h>

#include <string>

#include <fstream>

#include <sstream>

#include <stdint.h>

#include <pthread.h>

#include <vector>

#include <map>

#include <set>

using namespace std;

#define INIT(x) x = (typeof(x))(long)(&x)

class Data {

public:

    virtual ~Data() {};

    Data() {

        INIT(b);

        INIT(d);

        INIT(p);

        INIT(c);

        INIT(l);

    }

    bool b;

    double d;

    int* p;

    char c;

    long l;

    bool operator==(const Data& another) const {

        return another.b == b &&

               another.d == d &&

               another.p == p &&

               another.c == c &&

               another.l == l;

    }

    bool operator!=(const Data& another) const {

        return !(*this == another);

    }

    void Print() const {

        printf("Data::b:%d\n", b);

        printf("Data::d:%f\n", d);

        printf("Data::p:%p\n", p);

        printf("Data::c:%c(%d)\n", c, (unsigned char)c);

        printf("Data::l:%ld\n", l);

    }

};

class Base {

public:

    Base() {

        INIT(p);

        INIT(c);

        i1 = c + random();

        i2 = c + random();

        INIT(d);

        u3 = c + random();

    }

    virtual ~Base() {};

    void* p;

    char c;

    int i1:1;

    int i2:2;

    double d;

    unsigned int u3:3;

    bool operator==(const Base& another) const {

        return another.p  == p  &&

               another.c  == c  &&

               another.i1 == i1 &&

               another.i2 == i2 &&

               another.d  == d  &&

               another.u3 == u3;

    }

    bool operator!=(const Base& another) const {

        return !(*this == another);

    }

    virtual void Print() const {

        printf("Base::p:%p\n", p);

        printf("Base::c:%c(%d)\n", c, (unsigned char)c);

        printf("Base::i1:%d\n", i1);

        printf("Base::i2:%d\n", i2);

        printf("Base::d:%f\n", d);

        printf("Base::u3:%u\n", u3);

    }

};

class Derive: public Base {

public:

    Derive() {

        INIT(i);

        INIT(c);

        u1 = i + random();

        u2 = i + random();

        u3 = i + random();

        u4 = i + random();

        INIT(b);

        INIT(ui);

        INIT(uf);

        INIT(d);

    }

    int i;

    char c;

    unsigned u1:10;

    unsigned u2:10;

    Data dt;

    unsigned u3:10;

    unsigned u4:2;

    bool b;

    union {

        int ui;

        float uf;

    };

    double d;

    virtual void Print() const {

        Base::Print();

        printf("Derive::i:%d\n", i);

        printf("Derive::c:%c(%d)\n", c, (unsigned char)c);

        printf("Derive::u1:%d\n", u1);

        printf("Derive::u2:%d\n", u2);

        dt.Print();

        printf("Derive::u3:%d\n", u3);

        printf("Derive::u4:%d\n", u4);

        printf("Derive::b:%d\n", b);

        printf("Derive::ui:%d\n", ui);

        printf("Derive::uf:%f\n", uf);

        printf("Derive::d:%f\n", d);

        printf("\n");

    }

    bool operator==(const Derive& another) const {

        return Base::operator ==(another) &&

               another.i  == i  &&

               another.c  == c  &&

               another.u1 == u1 &&

               another.u2 == u2 &&

               another.dt == dt &&

               another.u3 == u3 &&

               another.u4 == u4 &&

               another.b  == b  &&

               another.ui == ui &&

               another.uf == uf &&

               another.d  == d;

    }

    bool operator!=(const Derive& another) const {

        return !(*this == another);

    }

};

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

    printf("sizeof(Data):%lu\n", sizeof(Data));

    printf("sizeof(Base):%lu\n", sizeof(Base));

    printf("sizeof(Derive):%lu\n", sizeof(Derive));

    printf("\n");

    Derive drv;

    {

        string s((const char*)&drv, sizeof(Derive));

        const Derive* p = reinterpret_cast<const Derive*>(s.c_str());

        if (*p == drv) {

            cout << "*EQUAL*" << endl;

            p->Print();

        }

    }

    drv.i = 1;

    drv.c = 'a';

    drv.u1 = 10;

    drv.u2 = 20;

    drv.u3 = 30;

    drv.u4 = 2;

    drv.b = true;

    drv.ui = 3;

    drv.uf = 3.5;

    drv.d = 8.8;

    {

        string s((const char*)&drv, sizeof(Derive));

        const Derive* p = reinterpret_cast<const Derive*>(s.c_str());

        if (*p == drv) {

            cout << "*EQUAL*" << endl;

            p->Print();

        }

    }

    for (int i = 0; i < 10 * 1024; ++i) {

        Derive* pdrv = new Derive();

        {

            string s((const char*)pdrv, sizeof(Derive));

            const Derive* p = reinterpret_cast<const Derive*>(s.c_str());

            if (*p != *pdrv) {

                cout << "*NOT EQUAL*" << endl;

                pdrv->Print();

                p->Print();

                break;

            }

        }

        delete pdrv;

    }

    return 0;

}

==================     run result     ===================

so true 2015-03-04 15:34 发表评论

#include <iostream>

#include <string>

#include <fstream>

#include <sstream>

#include <stdint.h>

#include <pthread.h>

#include <vector>

#include <map>

#include <set>

using namespace std;

void fun() {

    cout << __PRETTY_FUNCTION__ << endl;

}

namespace {

    void fun(int i) {

        cout << __PRETTY_FUNCTION__ << endl;

        ::fun(); //use fun() will compile error

    }

}

class A {

public:

    void fun() {

        cout << __PRETTY_FUNCTION__ << endl;

    }

    void fun(int x) {

        cout << __PRETTY_FUNCTION__ << endl;

    }

};

class B: public A {

public:

    //using A::fun; //solution 3

    void fun(int x) {

        cout << __PRETTY_FUNCTION__ << endl;

    }

};

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

    B b;

    //b.fun();//compile error, name hiding occurs

    b.A::fun(); //solution 1

    A* pa = &b;

    pa->fun();  //solution 2

    fun(3);

    return 0;

}

===================   run result   ===================

so true 2015-03-03 14:34 发表评论

#include <iostream>
#include <string>
#include <fstream>
#include <sstream>
#include <stdint.h>
#include <string.h>
#include <pthread.h>
#include <vector>
#include <map>
#include <set>

using namespace std;

int LCS(const char* X, const char* Y, char* R) {
    if (NULL == X || NULL == Y || NULL == R) {
        return 0;
    }

    int xlen = strlen(X);
    int ylen = strlen(Y);

    map<int, map<int, int> > D;
    for (int i = 0; i < xlen; ++i) {
        int max = 0;
        for (int j = 0; j < ylen; ++j) {
            max = std::max(X[i] == Y[j] ? 1 : 0, max);
            if (i > 0) {
                max = std::max(D[i - 1][j], max);
                if (j > 0) {
                    max = std::max(D[i - 1][j - 1] + (X[i] == Y[j] ? 1 : 0), max);
                }
            }
            D[i][j] = max;
            printf("(%d,%d) = %d\n", i, j, max);
        }
    }

    return D[xlen - 1][ylen - 1];
}

int main(int argc, char* argv[]) {
    const char* X = argc > 1 ? argv[1] : "abacbda";
    const char* Y = argc > 2 ? argv[2] : "cbada";
    char R[1024];
    printf("X:%s\n", X);
    printf("Y:%s\n", Y);
    int ret = LCS(X, Y, R);
    printf("ret:%d\n", ret);
    return 0;
}

so true 2015-02-20 15:37 发表评论

#include <iostream>

#include <stdlib.h>

#include <string>

#include <vector>

#include <map>

#include <math.h>

#include <set>

using namespace std;

class MatchPointFinder {

public:

    double GetDistanceBetweenTwoPoints(int x1, int y1, int x2, int y2, double alpha) const {

        return (abs(x1 - x2) + abs(y1 - y2)) * alpha;

        //return (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);

        //two methods will *not* be equivalent under the following way of calculating distance, for the case in "main"

        //return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));

    }

    double CalcSumDistance(int x, int y) {

        double dist = 0.0f;

        for (typeof(m_node_pos.begin()) it = m_node_pos.begin(), it4End = m_node_pos.end(); it4End != it; ++it) {

            dist += GetDistanceBetweenTwoPoints(it->first.first, it->first.second, x, y, it->second);

        }

        return dist;

    }

    MatchPointFinder(): m_width(0), m_height(0), m_match_point_x(0), m_match_point_y(0), m_total_weight(0), m_nodes(NULL) {

    }

    void ValidateEquivalenceOfTwoMethods(int trial_num = 1000) {

        for (int i = 0; i < trial_num; ++i) {

            int width = 5 + rand() % 100;

            int height = 5 + rand() % 100;

            Reset();

            RandomInit(width, height);

            if (!CompareTwoMethod()) {

                Try();

                break;

            } else {

                printf("two methods are equivalent under %d x %d array scale\n", height, width);

            }

        }

    }

    void Try() {

        FindMatchPointByEnumerating(m_match_point_x, m_match_point_y);

        printf("total weight is %f\n", m_total_weight);

        PrintMap(false);

        PrintMap();

        int old_mp_x = m_match_point_x;

        int old_mp_y = m_match_point_y;

        FindMatchPointByMedianMethod(m_match_point_x, m_match_point_y);

        PrintMap(false);

        if (old_mp_x == m_match_point_x && old_mp_y == m_match_point_y) {

            printf("two methods are equivalent under %d x %d array scale\n", m_height, m_width);

        } else {

            printf("two methods are *not* equivalent under %d x %d array scale\n", m_height, m_width);

        }

    }

    template <typename T>

    T abs(const T& t) const {

        return t > 0 ? t : -1 * t;

    }

    bool CompareTwoMethod() {

        FindMatchPointByEnumerating(m_match_point_x, m_match_point_y);

        int old_mp_x = m_match_point_x;

        int old_mp_y = m_match_point_y;

        FindMatchPointByMedianMethod(m_match_point_x, m_match_point_y);

        if (old_mp_x == m_match_point_x && old_mp_y == m_match_point_y) {

            return true;

        } else if (abs(m_node_dist[std::make_pair(old_mp_x, old_mp_y)] - m_node_dist[std::make_pair(m_match_point_x, m_match_point_y)]) < 0.000001) {

            return true;

        }

        return false;

    }

    ~MatchPointFinder() {

        Reset();

    }

    void RandomInit(int width = -1, int height = -1, bool init_random = true) {

        if (-1 != width) {

            m_width = width;

        }

        if (-1 != height) {

            m_height = height;

        }

        srand(time(NULL));

        m_nodes = new double*[m_height];

        memset(m_nodes, 0, sizeof(double*) * m_height);

        for (int i = 0; i < m_height; ++i) {

            if (!init_random) {

                m_nodes[i] = new double[m_width];

                memset(m_nodes[i], 0, sizeof(int) * m_width);

            } else {

                for (int j = 0; j < m_width; ++j) {

                    if (0 == j) {

                        m_nodes[i] = new double[m_width];

                        memset(m_nodes[i], 0, sizeof(int) * m_width);

                    }

                    m_nodes[i][j] = ((rand() % 10) >= 5 ? (double)(1 + rand() % 3) / 5 : 0);

                    if (m_nodes[i][j]) {

                        m_node_pos[std::make_pair(i, j)] = m_nodes[i][j];

                        m_total_weight += m_nodes[i][j];

                    }

                }

            }

        }

    }

    void AddNode(int x, int y) {

        m_nodes[x][y] = 1;

        m_node_pos[std::make_pair(x, y)] = 1;

        m_total_weight += 1;

    }

    void FindMatchPointByMedianMethod(int& mp_x, int& mp_y) {

        double collected_weight = 0;

        mp_x = -1;

        for (int i = 0; i < m_height; ++i) {

            for (int j = 0; j < m_width; ++j) {

                if (m_nodes[i][j] <= 0) {

                    continue;

                }

                collected_weight += m_nodes[i][j];

                if (collected_weight >= m_total_weight / 2) {

                    mp_x = i;

                    break;

                }

            }

            if (-1 != mp_x) {

                break;

            }

        }

        collected_weight = 0;

        mp_y = -1;

        for (int j = 0; j < m_width; ++j) {

            for (int i = 0; i < m_height; ++i) {

                if (m_nodes[i][j] <= 0) {

                    continue;

                }

                collected_weight += m_nodes[i][j];

                if (collected_weight >= m_total_weight / 2) {

                    mp_y = j;

                    break;

                }

            }

            if (-1 != mp_y) {

                break;

            }

        }

    }

    void FindMatchPointByEnumerating(int& mp_x, int& mp_y) {

        double shortest_sum_dist = std::numeric_limits<double>::max();

        for (int i = 0; i < m_height; ++i) {

            for (int j = 0; j < m_width; ++j) {

                double dist = CalcSumDistance(i, j);

                m_node_dist[std::make_pair(i, j)] = dist;

                if (dist < shortest_sum_dist) {

                    shortest_sum_dist = dist;

                    mp_x = i;

                    mp_y = j;

                }

            }

        }

    }

    void PrintMap(bool print_dist = true) {

        printf("%4s ", " ");

        for (int i = 0; i < m_width; ++i) {

            printf("      (%2d) ", i);

        }

        printf("\n");

        for (int i = 0; i < m_height; ++i) {

            printf("(%2d) ", i);

            for (int j = 0; j < m_width; ++j) {

                if (i == m_match_point_x && j == m_match_point_y) {

                    if (print_dist) {

                        printf("*%.1f[%2.1f] ", m_nodes[i][j], m_node_dist[std::make_pair(i, j)]);

                    } else {

                        printf("      *%.1f ", m_nodes[i][j]);

                    }

                } else {

                    if (print_dist) {

                        printf("%.1f[%2.1f] ", m_nodes[i][j], m_node_dist[std::make_pair(i, j)]);

                    } else {

                        printf("      %.1f ", m_nodes[i][j]);

                    }

                }

            }

            printf("\n");

        }

        printf("\n");

    }

    void Reset() {

        if (m_nodes) {

            for (int i = 0; i < m_height; ++i) {

                delete [] m_nodes[i];

            }

            delete [] m_nodes;

        }

        m_nodes = NULL;

        m_width = 0;

        m_height = 0;

        m_match_point_x = 0;

        m_match_point_y = 0;

        m_total_weight = 0;

        m_node_pos.clear();

        m_node_dist.clear();

    }

private:

    int m_width;

    int m_height;

    int m_match_point_x;

    int m_match_point_y;

    double m_total_weight;

    double** m_nodes;

    std::map<std::pair<int, int>, double> m_node_pos;

    std::map<std::pair<int, int>, double> m_node_dist;

};

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

    int width = 5;

    int height = 5;

    if (argc > 1) {

        height = atoi(argv[1]);

    }

    if (argc > 2) {

        width = atoi(argv[2]);

    }

    MatchPointFinder mpf;

    //mpf.RandomInit(width, height);

    //mpf.Try();

    //return 0;

    mpf.ValidateEquivalenceOfTwoMethods(1000);

    return 0;

    /*

                           ( 0)       ( 1)       ( 2)       ( 3)       ( 4)

                ( 0)          1          1          0          0          1

                ( 1)          1          0          0          1          0

                ( 2)          1          1          0          1          0

                ( 3)          0          0       *  1          1          0

                ( 4)          1          1          1          1          1

    */

    mpf.Reset();

    mpf.RandomInit(5, 5, false);

    mpf.AddNode(0, 0);

    mpf.AddNode(0, 1);

    mpf.AddNode(0, 4);

    mpf.AddNode(1, 0);

    mpf.AddNode(1, 3);

    mpf.AddNode(2, 0);

    mpf.AddNode(2, 1);

    mpf.AddNode(2, 3);

    mpf.AddNode(3, 2);

    mpf.AddNode(3, 3);

    mpf.AddNode(4, 0);

    mpf.AddNode(4, 1);

    mpf.AddNode(4, 2);

    mpf.AddNode(4, 3);

    mpf.AddNode(4, 4);

    mpf.Try();

    return 0;

}

so true 2015-02-07 20:34 发表评论

so true 2015-02-01 12:44 发表评论

http://valgrind.org/docs/manual/ms-manual.html

http://manyhappy163.blog.163.com/blog/static/16447683120105174149969/

http://hi.baidu.com/algorithms/item/77e5c6bfed350d77244b097f

经过调查，结论是：

1。map不能使用swap的方式来强制释放内存；

2。map用的allocator，新版gcc用new_allocator，不存在pool的问题；

3。根本原因是free函数（libc内部实现），并没有把你内存真正的释放，这个与free的内部实现机制有关了。

下面是一个小的测试程序

$ cat test_mem_seg.cpp 

#include <vector>

#include <malloc.h>

#include <stdio.h>

#include <iostream>

#include <stdlib.h>

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

    std::vector<void*> v;

    int block_len = 120;

    if (argc > 1) {

        block_len = atoi(argv[1]);

    }

    for (int i = 0; i < 1024 * 1024; ++i) {

        char* p = (char*)malloc(block_len);

        sprintf(p, "%d", i);

        v.push_back(p);

    }

    std::cout << "\n===============malloc (block unit size:" << block_len << ") ok==============\n";

    malloc_stats();

    for (int i = 0; i < 1024 * 1024; ++i) {

        free(v[i]);

    }

    std::cout << "\n===============free  (block unit size:" << block_len << ") ok==============\n";

    malloc_stats();

}

so true 2014-09-18 14:26 发表评论

http://vimcolorschemetest.googlecode.com/svn/html/bensday-c.html

如果喜欢，现在教你如何在terminal下达到该效果（注意：不是在gvim下）：

1。add the following line in .bashrc：

export TERM=xterm-256color

so true 2014-04-15 19:13 发表评论

1。断言是一个对当前匹配位置之前或之后的字符的测试；

2。断言不会实际消耗任何字符； #这一点至关重要

通常的用法： (?<=a)b(?=c) #b的前瞻是c，后瞻是a；

前瞻左置用法：(?=\d)\w+ #\w+需要以\d开始；

后瞻右置用法：\w+(?<=\d) #\w+需要以\d结束；

上面三种用法中，我们姑且把b和\w+称为修饰项。

对于后两种用法，要求 前瞻/后瞻 里用以约束修饰项的字符应当是修饰项的子集，否则就不太合适，例如：

a(?<=b)永远不可能成立，因为a!=b；

(?=a)b永远不可能成立，因为a!=b;

$ echo 'foobar' | grep -o -P '(?!foo)bar' #它不能用于查找之前出现所有不是 ”foo” 的 ”bar” 匹配， 它会查找到任意的 ”bar” 出现的情况， 因为 (?!foo) 这个断言在接下来三个字符时 ”bar” 的时候是永远都 TRUE 的(因为foo!=bar)。

bar

$ echo '!abcae20a' | grep -o -P '\w{4,}(?=.*\d)' #0用于支撑后面的前瞻断言

abcae2

$ echo '!abcae20a' | grep -o -P '\w{4,}(?<=\d)' #0不需要拿出来支撑断言

abcae20

$ echo '!abcae20' | grep -o -P '\w{4,}(?<=.*\d)' #后瞻断言必须定长

grep: lookbehind assertion is not fixed length

$ echo '!abcae20' | grep -o -P '(?=.*\d)\w{4,}' #这个前瞻左置断言不定长，而且前瞻过程中没有任何字符约束，也比较诡异，匹配不出结果，最好不要这样写

$ echo 'a2 abcae20a' | grep -o -P '(?=.*\d)\w+' #这个前瞻左置断言不定长，而且前瞻过程中没有任何字符约束，也比较诡异，只匹配出部分结果，最好不要这样写

a2

$ echo '!abcae20' | grep -o -P '(?=\w+\d)\w{4,}' #这个前瞻断言虽然不定长，但是里面的字符都在修饰项的范畴内

abcae20

$ echo 'a2 ab!cae20a' | grep -o -P 'a(?=.*\d)\w+' #注意对于第2组结果'ab'，里面并不包含数字，但是其后面有数字20，因此前瞻断言成立

a2

ab

ae20a

$ echo '!abcae20' | grep -o -P '.*?(?=.*\d)\w{4,}' #可以用最开始的.*来吸收不属于\w的字符

!abcae20

$ echo '!a21ed0' | grep -o -P '(?=(?:\w*?\d){3,})\w{6,}' #实现了最终想要的功能：一个字符串至少有6个字符，而且至少有3个数字

a21ed0

总结：前瞻断言放在修饰项后面比较容易理解；放在修饰项前面时：主要用于概括性的规定修饰项里包含的内容，因此此时的前瞻断言里允许出现的字符应该都是修饰项里可接受的字符

更多详细介绍可以参见：http://www.php.net/manual/zh/reference.pcre.pattern.syntax.php

so true 2013-11-20 20:27 发表评论

set expandtab

set tabstop=4

set shiftwidth=4

set cursorline

set list
set hlsearch

syntax on

set listchars=tab:>-,trail:-

highlight WhitespaceEOL ctermbg=magenta guibg=magenta

match WhitespaceEOL /\s\+$\|\t/

autocmd BufReadPost * if line("'\"") > 0 && line("'\"") <= line("$") | exe "normal g'\"" | endif

inoremap <C-h> <Left>

inoremap <C-j> <Down>

inoremap <C-k> <Up>

inoremap <C-l> <Right>

inoremap <C-a> <ESC>0i

inoremap <C-u> <ESC>A

so true 2013-08-26 16:47 发表评论

trap 'date' SIGUSR2

echo before

while true; do

    sleep 0.01

done

echo after

kill -SIGUSR2 XXX #date立即被执行

kill -SIGUSR2 XXX #date立即被执行

--------------------------------------

trap 'date' SIGUSR2

echo before

sleep 10

echo after

kill -SIGUSR2 XXX #date未被执行，直到sleep 10结束后立即被执行，最后再打印出after

--------------------------------------

trap 'date' SIGUSR2

echo before

sleep 100 &

wait

echo after

kill -SIGUSR2 XXX #wait被立即中断（wait的返回码是一个大于128的值），date立即被执行，然后打印出after退出

--------------------------------------

shell在执行过程中，在一个命令执行过程中不会执行trap指定的命令，只有在命令执行完之后才会执行trap指定的命令；

Ctrl+c #给程序发送SIGINT信号

Ctrl+\ #给程序发送SIGTERM信号

bash shell会忽略SIGQUIT信号，即：1个shell进程run时发SIGQUIT不会退出；但你自己编译的程序run时收到SIGQUIT是会退出的

用EXIT来做清理：trap "{ rm -f $tmp_file ; exit 255; }" EXIT

用ERR来做警告，可以参见：http://blog.csdn.net/sosodream/article/details/5681893和http://blog.csdn.net/sosodream/article/details/5724650

用DEBUG来做调试，例如来跟踪变量的变化：

trap "echo tmp_value is being changed." DEBUG

bla bla bla

declare -t tmp_value=38

so true 2013-08-14 16:08 发表评论

so true 2013-07-31 16:55 发表评论

# A small example program for using the new getopt(1) program.

# This program will only work with bash(1)

# An similar program using the tcsh(1) script language can be found

# as parse.tcsh

# Example input and output (from the bash prompt):

# ./option_test.sh -a par1 'another arg' --c-long 'wow!*\?' -cmore -b " very long "

# Option a

# Option c, no argument

# Option c, argument `more'

# Option b, argument ` very long '

# Remaining arguments:

# --> `par1'

# --> `another arg'

# --> `wow!*\?'

# Note that we use `"$@"' to let each command-line parameter expand to a

# separate word. The quotes around `$@' are essential!

# We need TEMP as the `eval set --' would nuke the return value of getopt.

#-o表示短选项，两个冒号表示该选项有一个可选参数，可选参数必须紧贴选项

#如-carg 而不能是-c arg

#--long表示长选项

#"$@"在上面解释过

# -n:出错时的信息

# -- ：举一个例子比较好理解：

#我们要创建一个名字为 "-f"的目录你会怎么办？

# mkdir -f #不成功，因为-f会被mkdir当作选项来解析，这时就可以使用

# mkdir -- -f 这样-f就不会被作为选项。

TEMP=`getopt -o ab:c:: -l a-long,b-long:,c-long:: -n 'option_test.sh' -- "$@"`

echo "TEMP:{$TEMP}"

if [ $? != 0 ] ; then echo "Terminating..." >&2 ; exit 1 ; fi

# Note the quotes around `$TEMP': they are essential!

#set 会重新排列参数的顺序，也就是改变$1,$2...$n的值，这些值在getopt中重新排列过了

eval set -- "$TEMP" #必须用eval

echo "\$#: $#"

for i in "$@"; do

    echo "{$i}"

done

#经过getopt的处理，下面处理具体选项。

while true ; do

        case "$1" in

                -a|--a-long) echo "Option a" ; shift ;;

                -b|--b-long) echo "Option b, argument \`$2'" ; shift 2 ;;

                -c|--c-long)

                        # c has an optional argument. As we are in quoted mode,

                        # an empty parameter will be generated if its optional

                        # argument is not found.

                        case "$2" in

                                "") echo "Option c, no argument"; shift 2 ;;

                                *)  echo "Option c, argument \`$2'" ; shift 2 ;;

                        esac ;;

                --) shift ; break ;;

                *) echo "Internal error!" ; exit 1 ;;

        esac

done

echo "Remaining arguments:"

for arg do

   echo '--> '"\`$arg'" ;

done

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

so true 2013-07-11 11:27 发表评论

相关解释参见：http://www.cl.cam.ac.uk/~mgk25/ucs/quotes.html；

我是从http://www.trilithium.com/johan/2005/07/quotation-marks/找到上面那个解释的文章的；

我是通过google `bash grave accent apostrophe quote' 在第2页发现的上面那个博客的。

so true 2013-07-11 11:09 发表评论

epoll使用总结                                  http://laokaddk.blog.51cto.com/368606/617497

epoll学习：思考一种高性能的服务器处理框架           http://laokaddk.blog.51cto.com/368606/607231

epoll学习笔记                                  http://laokaddk.blog.51cto.com/368606/607017

简单学习了一下epoll，之前也用过，这次又看了看，收获如下：

两种实现模式（在http://laokaddk.blog.51cto.com/368606/791945中都有提到）：同一个线程 和 不同线程；

顺便了解了一下惊群现象，如果用accept阻塞的方式就不存在惊群现象了，在不同线程中通过epoll_wait来出发accept行为的nginx的解决方法是通过进程里原子的修改寄存器a来做到进程间互斥的。

在不同线程模式下：listenfd需设置为非阻塞，注册EPOLLIN就可以了，触发时调用accept，有没有连接都会立刻返回；

在同一个线程模式下：listenfd为阻塞模式，不注册epoll，阻塞while调用accept即可；

ET触发只支持非阻塞模式，这里针对的fd是accept接收到的然后epoll_add了的那些fds，原因是：因为ET触发需要处理函数一直处理完所有in/out数据，比如read数据，如果read到的字节数小于预先准备读入的字节数，那么就可以认为读完了；如果是非阻塞模式，那么read会一直阻塞在那里。

epollfd不需要设置阻塞、非阻塞。

一般都用LT触发，不论哪种实现模式，EPOLLIN和EPOLLOUT都不同时设定，都是不断切换来做的。

客户端close掉socket时，会唤醒服务端epoll_wait;

对于epoll_wait而言，针对一个fd只存在唤醒与被唤醒，至于是EPOLLIN还是EPOLLOUT，取决于你当初epoll_add时的设定，因此如果你epoll_add时设定了EPOLLIN|EPOLLOUT，那么当EPOLLIN发生时（内核里当然是可以区分EPOLLIN和EPOLLOUT的），你收到的fd上的事件依然是EPOLLIN|EPOLLOUT。

so true 2013-07-04 17:36 发表评论

第一盘专辑《最后圆舞曲》，由皇星在1985年出版：http://blog.sina.com.cn/s/blog_4bbafd5001011yq2.html；

当时这张唱片的制作公司是“心声唱片”(sing song)，发行公司是“皇星唱片”(king star)。严格说来这张唱片并不能算是“出品”，根据华健的一些访谈了解到，在唱片发行之前，发行公司皇星唱片便倒闭了，所以这张《最后圆舞曲》并没有真正发行。

后在1987年再版：http://tieba.baidu.com/p/575579301，并在里面增加了《苹果派的滋味》、《Danny's Song》、《谁曾说过》、《愁》四首歌；

时间到了1993年，江苏省文化音像出版社录音发行总公司从心声唱片处得到了《最后圆舞曲》以及与《最后圆舞曲》同时期一些华健歌曲的版权，经过重新设计，推出了《最后圆舞曲》的引进版——《永远陪伴你》。江苏省文化音像出版社录音发行总公司当时推出的是《永远陪伴你》的卡带。之后，中国唱片广州公司又从江苏省文化音像出版社录音发行总公司处得到了《永远陪伴你》的CD版发行权和黑胶唱片发行权，推出了CD版和黑胶版的《永远陪伴你》，这盘专辑去掉了《梦里的中国》三部曲，而且专辑中的歌曲名字和《最后圆舞曲》中的歌名基本都不一致，对应关系如下：

1.永远陪伴你（最后圆舞曲）

2.苦苦等待你（苹果派的滋味）

3.不愿再回首（蜕）

4.平凡的感觉（平凡的感觉）

5.在我胸中燃烧（钟声）

6.我曾经年少（短歌）

7.无言的声韵（夜深人静）

8.谁曾说过（谁曾说过）

9.Danny's Song（Danny's Song）

10.在梦里（愁）

11.雨中的温馨（雨中的温馨）

12.如今伴我只是一个结（结）

此外， 《苦苦等待你》、《Danny Sony 丹妮索妮》、《我多幸运》这三盘专辑和《永远陪伴你》是一样的，只不过专辑名字不一样，其中《Danny Sony 丹妮索妮》最为著名。

此后，华健加入了滚石唱片，发行唱片如下：

1987.07《心的方向》

1988.04《Sad Without You》

1988.10《我付出我的真爱 我实现我的梦》，《阳光游子》也是这盘专辑

1989.03《期待更多 付出更多》，《家和我一起成长》也是这盘专辑

1990.02《最真的梦》，《再爱我吧》也是这盘专辑

1990.12《不愿一个人》 

1991.02《青鸟 Blue Bird》

1991.12《让我欢喜让我忧》

1992.05《I Remember》

1993.04《花心》

1993.08《Songs Of Birds》

1994.06《风雨无阻》

1994.10《有弦相聚》 

1995.01《我愿意去等》

1995.07《爱相随》

1995.12《弦途有你》

1996.02《爱的光》

1996.05《弦弦全全》

1996.07《Forever Young》

1996.07《小天堂》

1996.12《生 生活》 

1997.04《朋友》

1997.11《光阴似箭》 

1997.12《世界由你我开始》

1998.08《有故事的人》

1999.02《My Oh My 至爱吾爱》

1999.05《人猿泰山》

1999.12《现在》 

2001.10《忘忧草》

2003.07《一起吃苦的幸福》 

2006.03《雨人》

2011.05《花旦》

推荐一个链接，里面对华健专辑歌词整理得很不错：http://mojim.com/cnh100052.htm
未完待续。
这是我收录的卡带：

so true 2013-05-09 18:51 发表评论