前段时间遇到一个问题，如果有多个动态链接库同时link另外一个静态链接库，这个静态库里的全局变量（或者static变量）会怎么样呢？
拍脑袋想想，总共也就这么几种可能：
仔细想想，分析一下，各种可能性都有，得看这些库和可执行文件是怎么编译链接的才行，具体看下面的各种case。
同时，测试的code里在dynamic里加上了同名的函数，看看函数会有什么表现。
假设有如下文件(code见Gist)：
common.h
common.cpp // 生成libcommon.a
dynamic1.h
dynami1.cpp // 生成libdynamic1.so
dynamic2.h
dynamic2.cpp // 生成libdynamic2.so
main.cpp // 生成main
生成libcommon.a总是这么编译：
g++ -g -Wall -Wextra -c -o common.o common.cpp
ar rcs libcommon.a common.o
g++ -g -Wall -Wextra -fPIC -shared -o libdynamic1.so dynamic1.cpp
g++ -g -Wall -Wextra -fPIC -shared -o libdynamic2.so dynamic2.cpp
g++ -DDIRECT_CALL_SO -o main main.cpp -L. -ldynamic1 -ldynamic2
这种情况结果显然是4，link时出错，找不到.a里的函数。
g++ -g -Wall -Wextra -fPIC -shared -o libdynamic1.so dynamic1.cpp
g++ -g -Wall -Wextra -fPIC -shared -o libdynamic2.so dynamic2.cpp
g++ -DDIRECT_CALL_SO -o main main.cpp -L. -ldynamic1 -ldynamic2 -lcommon
LD_LIBRARY_PATH=. ./main
这种情况下执行的结果是2，link时没错，执行时看到的也是同一个变量。
GetInt()返回值是1，它依赖于-l的顺序，如果-ldynamic2在前，返回值就是2了。
g++ -g -Wall -Wextra -fPIC -shared -o libdynamic1.so dynamic1.cpp -L. -lcommon
g++ -g -Wall -Wextra -fPIC -shared -o libdynamic2.so dynamic2.cpp -L. -lcommon
g++ -DDIRECT_CALL_SO -o main main.cpp -L. -ldynamic1 -ldynamic2
LD_LIBRARY_PATH=. ./main
执行结果同上
dlopen()调用so，无所谓链接.a
g++ -g -Wall -Wextra -fPIC -shared -o libdynamic1.so dynamic1.cpp
g++ -g -Wall -Wextra -fPIC -shared -o libdynamic2.so dynamic2.cpp
g++ -o main main.cpp -ldl [-L. -lcommon]
LD_LIBRARY_PATH=. ./main
执行结果是4，dlopen的时候找不到 GetGlobalStatic()。
dlopen()调用so(不用RTLD_GLOBAL)，无所谓链接.a
g++ -g -Wall -Wextra -fPIC -shared -o libdynamic1.so dynamic1.cpp -L. -lcommon
g++ -g -Wall -Wextra -fPIC -shared -o libdynamic2.so dynamic2.cpp -L. -lcommon
g++ -o main main.cpp -ldl
LD_LIBRARY_PATH=. ./main
执行结果是3，各有各自的变量。
GetInt()返回的也是各自的变量。
dlopen()调用so(使用RTLD_GLOBAL)，无所谓链接.a
g++ -g -Wall -Wextra -fPIC -shared -o libdynamic1.so dynamic1.cpp -L. -lcommon
g++ -g -Wall -Wextra -fPIC -shared -o libdynamic2.so dynamic2.cpp -L. -lcommon
g++ -DUSE_RTLD_GLOBAL -o main main.cpp -ldl -L. -lcommon
LD_LIBRARY_PATH=. ./main
执行结果变成2了，执行时看到了同一个变量。
GetInt()返回的仍然是各自的变量。
看了这么多case，结果1怎么没有出现呢？别急，如果编译的时候全部编译在一起：
g++ -DDIRECT_CALL_SO -o main main.cpp dynamic1.cpp dynamic2.cpp common.cpp
就出错了，GetInt()重定义。
结论
dlopen()的flag：
RTLD_LOCAL(默认)，各个so会使用各自的.a里的变量。RTLD_GLOBAL，就跟直接link一样，用同一个变量了。一般来说，Calibre Recipe关注的内容是定期更新的，比如说知乎日报的内容，文章列表每天都会全部更新。
但如果某些内容并不是完全更新，只是部分更新，怎么处理呢？
比如说简书的每周热门文章，某些文章因为热门会持续几周都在其中。这样的话Recipe应该怎么处理才能保证只抓取新的文章，而忽略以前收录的文章呢？
一个朴素的想法就是，把之前收录过的文章都保存起来，然后在recipe里添加要抓取文章之前先check一下有没有抓取过了。
然而在尝试这个朴素的想法的时候，发现在Recipe里保存数据是个问题——保存的文件找不到！
稍微debug了一下，然后看了一下calibre的实现，发现它在抓取过程中的working directory是`/tmp/`下的一个临时目录，完成之后还会被删掉，当然找不到了。。。
尝试一：绝对路径，它work，但是太丑了。
尝试二：如下python里一般获取cwd的方法都不work
os.getcwd() print os.path.dirname(os.path.realpath(__file__))
因为calibre在__init__.py里有`self.cwd = None` 然后`os.chdir()`
尝试三：遍历inpsect一层层的stack，结果只能找到`/usr/bin/`里面去
尝试四：最后突然想到，既然只是个环境变量，那在os.environ里一定有相关的信息嘛，直接打印看一下，发现
os.environ['PWD']
就是我想要的目录。于是，用这个目录当CWD就搞定了。
具体的code直接看这个commit了。
今天有同事问起来关于boost的smart pointer的事情，原因是别人有一段code用了boost::scoped_ptr<>*，review的时候被揪出来说这不符合常理，讨论应该用啥容器。
基本情况就是有一些资源需要new出来放在一个容器里，这个容器的生命周期由自己控制，但是需要把new出来的东西作为一个数组（或者容器）传给别人。
原来的code写成了一个boost::scoped_ptr<>的数组，然后传给别人，像下面这样：
boost::scoped_ptr someResource[number];
for (int i = 0; i < number; ++i) {
someResource[i].reset(new T);
}
OtherFunction(someResource);
很显然，这样的code能编译，能正常工作（只要OtherFunction的实现没问题）；只是，真的太不符合common sense了。怎么整？
直觉上来说，既然是一个指针的数组，而且要传给别人，那用std::vector<boost::shared_ptr<T>>最合适了，然后传个const&给别人，搞定。
不过看到瑞典同事有人用boost::ptr_vector，这个新鲜的玩意儿不常见，研究一下，原来是Boost.Pointer Container的一部分，用来保存heap-allocated objects，有放进去的指针会在出了作用域之后自动删除，所以有”own”的语义。
相比起shared_ptr的容器，有各种优点（见上面link里的advantages 1~8）。
当然，最主要的是语义上的不同：
然后，从效率上来说，ptr_vector显然要更好一点，因为创建shared_ptr还是有开销的。
回到上面的case，最简单的做法就是用shared_ptr的容器；更合适的做法是用ptr_vector。
那么，它们的效率到底能差多少呢？写段code跑跑看。
#include <boost/ptr_container/ptr_vector.hpp>
#include <boost/shared_ptr.hpp>
#include <vector>
#include <cstdio>
#include <ctime>
#include <stdint.h>
class TSomeData
{
private:
int data;
public:
TSomeData(int d)
: data(d)
{
// Empty
}
};
const int TEST_ITERATIONS = 10000000;
typedef std::vector<boost::shared_ptr > TVectorOfShared;
typedef boost::ptr_vector TPtrVector;
int main()
{
clock_t start;
clock_t end;
start = ::clock();
TVectorOfShared vectorOfShared;
for (int i = 0; i < TEST_ITERATIONS; ++i) {
// Test vector of shared_ptr
boost::shared_ptr data(new TSomeData(i));
vectorOfShared.push_back(data);
}
end = ::clock();
printf("Vector of shared:\n Time executed: %u\n",
static_cast<uint32_t>((end - start) / (CLOCKS_PER_SEC/1000)));
start = ::clock();
TPtrVector ptrVector;
for (int i = 0; i < TEST_ITERATIONS; ++i) {
// Test ptr_vector
TSomeData* data = new TSomeData(i);
ptrVector.push_back(data);
}
end = ::clock();
printf("PtrVector:\n Time executed: %u\n",
static_cast<uint32_t>((end - start) / (CLOCKS_PER_SEC/1000)));
return 0;
}
跑一下结果如下(老式T400,跑着Ubuntu 14.04).
# g++ -O0 Vector of shared: Time executed: 7227 PtrVector: Time executed: 1507 # g++ -O2 Vector of shared: Time executed: 5090 PtrVector: Time executed: 731
无论是-O0还是-O2，都有着明显的差距。
结论：在语义合适的情况下，用ptr_vector有更好的效率。
最后，在stackoverflow上看到，如果项目的编译环境已经用c++11了，可以用std::vector<std::unique_ptr<T>>，测试一下,结果有点吃惊。
首先，unique_ptr相关的测试code如下：
for (int i = 0; i < TEST_ITERATIONS; ++i) {
std::unique_ptr data(new TSomeData(i));
vectorOfUnique.push_back(std::move(data));
}
测试结果：
# g++ -O0 -std=c++0x Vector of Unique: Time executed: 5057 Vector of shared: Time executed: 4080 PtrVector: Time executed: 1681 # g++ -O2 -std=c++0x Vector of Unique: Time executed: 835 Vector of shared: Time executed: 1794 PtrVector: Time executed: 743
让我吃惊的是：
结论：
Q.E.D
以前介绍过在一根网线上承载两路网络，用了近两年，感觉不错。现在家里的网络设备越来越多，所以分享一下我家的网络连接和设备情况。
先上图
稍微详细的介绍：
其它手机、Pad、笔记本，都是wifi连接，做该做的事情，就不多说了。
总之，因为路由器和树莓派是不关机的，而且树莓派的硬盘上的内容基本上和PC是同步的，所以我觉得这样最大的好处是：
Q.E.D.