Oceanbase代码有关语言和编译器的奇技淫巧(一)

Oceanbase代码有关语言和编译器的奇技淫巧(一)

–TSI Factory懒人利器

在oceanbase各个server的读写请求处理逻辑中,经常会遇到需要某个临时对象来保存中间参数或中间结果,比较典型的是线程在处理请求时需要将收到的buffer反序列化到类似ObScanParam这样的对象中,然后再将对象传给到具体的处理方法,执行得到的结果也是要通过类似ObScanner这样的对象传出,序列话到buffer中,再传递给网络线程回包。因此这样对象的作用域仅仅限于网络请求的处理函数中,调用伪代码示意如下:

  1. void handlePacket(ObPacket &pkt)  
  2. {  
  3.         ObScanParam scan_param;  
  4.         ObScanner scanner;  
  5.         scan_param.deserialize(pkt.get_req_buffer());  
  6.         handle_scan(scan_param, scanner);  
  7.         scanner.serialize(pkt.get_res_buffer());  
  8.         response(pkt);  
  9. }  

其中scan_param和scanner做为handlePacket函数的栈对象是比较合理,而ob最初版本的代码也确实是这样写的,但是当我们做性能测试的时候发现这里会有问题,这两个对象要对buffer执行序列化和反序列化,因此他们本质上是内存容器,这就意味着在他们的生命周期中要使用额外的内存,因此它们要么在使用的时候临时申请和释放内存,要么就把对象本身做大尽量使用栈上空间,避免每次都从堆上申请内存。但是无论怎么做都因为这种在栈上使用临时对象的做法,都有比较大的构造和析构成本。有没有简单的办法重用这样的对象呢,TSIFactory因此而诞生,先来看看它的使用方法:

  1. ObScanner *scanner = GET_TSI(ObScanner);  

不同线程通过GET_TSI调用得到的是不同的实例,而在一个线程内部每次调用得到的都是同一个对象,在线程退出的时候自动析构,因此上述代码通过使用TSIFactory简单改造,可以实现对象的重用:

  1. void handlePacket(ObPacket &pkt)  
  2. {  
  3.         ObScanParam *scan_param = GET_TSI(ObScanParam);  
  4.         scan_param->reset();  
  5.         ObScanner *scanner = GET_TSI(ObScanner);  
  6.         scanner->reset();  
  7.         scan_param->deserialize(pkt.get_req_buffer());  
  8.         handle_scan(*scan_param, *scanner);  
  9.         scanner->serialize(pkt.get_res_buffer());  
  10.         response(pkt);  
  11. }  

下面来看看GET_TSI的实现,宏GET_TSI封装了对一个模板函数的调用:

  1. template <class T>  
  2. T *get_instance()  
  3. {  
  4.   static __thread T *instance = NULL;  
  5.   if (NULL == instance && INVALID_THREAD_KEY != key_)  
  6.   {  
  7.     ThreadSpecInfo *tsi = (ThreadSpecInfo*)pthread_getspecific(key_);  
  8.     if (NULL == tsi)  
  9.     {  
  10.       tsi = new(std::nothrow) ThreadSpecInfo();  
  11.       pthread_setspecific(key_, tsi);  
  12.     }  
  13.     instance = tsi->get_instance<T>();  
  14.   }  
  15.   return instance;  
  16. }  

代码比较简单,这里使用了gcc的特性,“static __thread”。有关它的特性,直接摘一段别人的中文说明如下(摘自http://blog.csdn.net/liuxuejiang158blog/article/details/14100897):

__thread是GCC内置的线程局部存储设施,存取效率可以和全局变量相比。__thread变量每一个线程有一份独立实体,各个线程的值互不干扰。 __thread使用规则:只能修饰POD类型(类似整型指针的标量,不带自定义的构造、拷贝、赋值、析构的类型,二进制内容可以任意复制memset,memcpy,且内容可以复原),不能修饰class类型,因为无法自动调用构造函数和析构函数,可以用于修饰全局变量,函数内的静态变量,不能修饰函数的局部变量或者class的普通成员变量,且__thread变量值只能初始化为编译器常量(值在编译器就可以确定const int i=5,运行期常量是运行初始化后不再改变const int i=rand())。

通过上面的说明,可以理解为什么只能用__thread声明指针而不是对象本身了,那么随之而来的就是另一个问题,什么时候释放这个对象。这里就靠代码中的ThreadSpecInfo来解决对象释放的问题,通过注册pthread specific的回调函数来在线程退出时析构这些tsi对象,而这里想要想清楚,如何管理多个不同类型对象的释放问题,如果保存不同类型的指针?如何调用他们的析构函数?还是来看一段代码:

  1. class TSINodeBase  
  2. {  
  3.   public:  
  4.     TSINodeBase() : next(NULL)  
  5.     {  
  6.     };  
  7.     virtual ~TSINodeBase()  
  8.     {  
  9.       next = NULL;  
  10.     };  
  11.     TSINodeBase *next;  
  12. };  
  13.   
  14. template <class T>  
  15. class TSINode : public TSINodeBase  
  16. {  
  17.   public:  
  18.     explicit TSINode(T *instance) : instance_(instance)  
  19.     {  
  20.     };  
  21.     virtual ~TSINode()  
  22.     {  
  23.       if (NULL != instance_)  
  24.       {  
  25.         instance_->~T();  
  26.         instance_ = NULL;  
  27.       }  
  28.     };  
  29.   private:  
  30.     T *instance_;  
  31. };  

看了代码应该基本清楚了,既然需要保存不同类型的指针,那么就用一个基类包来成链表,不同对象的指针分别用不同的TSINode来保存,析构的时候只需要调用每个TSINodeBase的析构函数就好了。

到此为止TSIFactory的实现原理已经清楚了,最后还有一点值得提一下,目前位置实现的TSIFactory管理的对象不能有构造函数参数,这个能不能实现呢,这里的一个难点是既然要支持构造函数参数,那么参数的数量就是不确定的,如何做呢?还是先来看代码:

  1. #define GET_TSI_ARGS(type, args…) \  
  2.     ({ \  
  3.       type *__type_ret__ = NULL; \  
  4.       Wrapper<type> *__type_wrapper__ = GET_TSI(Wrapper<type>); \  
  5.       if (NULL != __type_wrapper__) \  
  6.       { \  
  7.         __type_ret__ = __type_wrapper__->get_instance(); \  
  8.         if (NULL == __type_ret__) \  
  9.         { \  
  10.           __type_wrapper__->get_instance() = new(std::nothrow) type(args); \  
  11.           __type_ret__ = __type_wrapper__->get_instance(); \  
  12.         } \  
  13.       } \  
  14.       __type_ret__; \  
  15.     })  

如果要求T类不做任何修改,要实现变长参数的无障碍传递,用宏来处理最简单(当然我也没相出来其他办法)。然后就是使用无构造函数参数的Wrapper来包装T类的指针,在第一次使用的时候new出T的对象。

最后解释一下,TSI是什么意思,作者当初写这段代码的时候正在看车,研究大众很给力的TSI发动机,正好也可以解释成thread static instance,就取了这个名字…

这是一个奇技淫巧的系列,后续内容预告一下:

to_cstring的Sfinae魔术

大小为0对象的妙用

弱类型的应用

宏的变长模板

发表评论

电子邮件地址不会被公开。 必填项已用*标注