读性能超过Memcached 65%, 单核也超过redis, 支持日志支持掉电保护，欢迎试用

hellioncu

光靠你的一些描述不明白细节的

wlmqgzm

回复 51# hellioncu

呵呵, 总算有人来踩踩了.

由于这个项目是学习和练手项目, 代码随意性比较强, 很多试验性质的库都拿来测试, 期望能够沿用到一些目前世界最先进水平的东西, 而不是拿十年前的技术练手.
代码 修改也比较大, 代码一直也没有稳定下来, 一直到现在, 连最底层File_Mapping层的代码, 包括接口还在不断的变, 昨天还修改了File_mapping_read实现大块数据的Zero copy, 也是在追求一种极致和最佳方案.

因此, 主要是记录思路的变化, 修改和废弃的代码, 远远超过留下来的代码, 高并发下高性能是公认的难题, 这个领域是非常困难的, 国内一直也没有类似Oracle这样牛的数据库开发公司和高手,
很多资料也缺乏, 又是个人开发, 我觉得数据库开发主要是思路问题,
类似 Leveldb, mongodb, innodb 有很多东西都值得学习, 然后, 拿里面最核心最有价值的思路, 然后学习, 实践, 最终推出一个集中全部优点的产品.

这次设计是 C++软件领域 最新技术的堆砌:
1)目前主要采用了  mongodb的 File_mapping 高性能IO读写技术.测试缓冲读性能1.6GByte/s, 缓冲写性能1.1GByte/s, 无缓冲磁盘写350MByte/s, 无缓冲磁盘读700MByte/s (已经实现)
2)采用了读写分离的存储层设计, 彻底去掉了mongodb的大锁, File_mapping读, 实现无锁并发, Zero Copy,  File_mapping写, 实现单线程写, 其他线程写缓冲队列输入, 实现最高性能的Wait_free无等待并发...(已经实现)
3)采用了LevelDb 数据分层, 一次性写入, 以及 不断合并技术, 实现完全消灭随机写, 只有顺序写, 对SSD的寿命有很大提高, 也可以实现最大化的写入速度, 实现极高的插入性能....(正在写代码, 部分实现...)
4)采用了内存中只存放索引, 减少物理内存占用, 数据由Mapping缓冲, 数据部分可不用放在内存中, 利用SSD的极高随机读性能, 单机实现10亿级别以上数据量的处理.....(正在写代码, 部分实现...)
5)采用了 innodb 日志offset 作为事务进度的指标, 以及commit事务隔离的思路, 并在自己的代码中也采用类似的技术思路, 为第2个版本提供MVCC做好准备.(准备第2个版本中实现, 第1个版本预留空间和定义)
6)采用了目前世界上比较前沿, 技术难度非常大, 国内还很少实践的 Lock_free, Wait_free 高性能无锁无等待队列技术, 作为线程间通讯. (已经实现, 已经全部采用Wait_free_queue)
7)采用了完全 智能化 对象 的设计思路, 并减少代码层次, ....实现了智能化对象, , File_Mapping_write无锁空间扩展, 文件数量自动增加和大小自动扩展, 以及多个File_mapping_read对象无锁自动跟踪扩展的技术,
各种比较新的对象设计思路 (正在写代码, 部分实现....)
采用了NOSQL的字段名field_name(/field_id)下推到底(每个Row记录)的设计, 以便为今后 任意新增/删除字段, 不需要全表更新.....(部分实现, 正在写代码....)
9)采用了目前压缩和解压缩速度最快的压缩工具包LZ4, 作为存储层的压缩工具, 以便减少IO流量, 增加缓冲的效率, 进而提供更快的IO性能. 每秒解压缩性能500MByte. (已经实现)
10)采用了目前速度最快的crc32c硬件校验技术(intel SSE4.2指令), 每秒校验速度1.6GByte(已经实现)
11)采用了目前高性能网络库Boost Asio, 实现每秒单连接PingPong测试11.2万QPS, 4核CPU下PingPong测试多连接87万QPS的性能(已经实现)
..............

所以, 希望大家有什么好的新技术和新思路推荐一下, 谢谢......





   

wlmqgzm

下面是做的unsigned long long, unsigned int 压缩程序,  大约可以压缩一半的字节数,
这部分代码的压缩原理是: 整数可能只使用了一部分低位字节, 高位经常为零, 因此, 一个整数可以表示为非零字节数+非零字节的方式来表达.

1. #ifndef _union_integer_hpp
   
2. #define _union_integer_hpp
   
3. 
   
4. 
   
5. //  使用联合处理所有的压缩整数, 性能会比较高
   
6. union Union_long
   
7. {
   
8.   unsigned long long ulong1;
   
9.   unsigned int uint1;
   
10.   unsigned short ushort1;
    
11.   unsigned char uchar1;
    
12.   long long long1;
    
13.   int  int1;
    
14.   short short1;
    
15.   char  char1;
    
16.   unsigned char uchars[ sizeof( long long ) ];
    
17. };
    
18. 
    
19. union Union_int
    
20. {
    
21.   unsigned int uint1;
    
22.   unsigned short ushort1;
    
23.   unsigned char uchar1;
    
24.   int  int1;
    
25.   short short1;
    
26.   char  char1;
    
27.   unsigned char uchars[ sizeof( int ) ];
    
28. };
    
29. 
    
30. 
    
31. union Union_short
    
32. {
    
33.   unsigned short ushort1;
    
34.   unsigned char uchar1;
    
35.   short short1;
    
36.   char  char1;
    
37.   unsigned char uchars[ sizeof( short ) ];
    
38. };
    
39. 
    
40. #endif // _union_integer_hpp
    

复制代码

1. 
   
2. #include "union_integer.hpp"
   
3. 
   
4. #ifndef _compress_integer_hpp
   
5. #define  _compress_integer_hpp
   
6. 
   
7. 
   
8. class Compress_integer:  public boost::noncopyable
   
9. {
   
10. public:
    
11.   static  unsigned long   get_ulong( const unsigned char *chars_in );
    
12.   static  unsigned int       get_uint( const unsigned char *chars_in );
    
13.   static  unsigned short get_ushort( const unsigned char *chars_in );
    
14.   static  unsigned int   make_out( const unsigned long ulong_in, unsigned char *chars_out );
    
15.   static  unsigned int   make_out( const unsigned int uint_in, unsigned char *chars_out );
    
16.   static  unsigned int   make_out( const unsigned short ushort_in, unsigned char *chars_out );
    
17. 
    
18.   static  int self_test( void );
    
19. };
    
20. 
    
21. 
    
22. Compress_integer    compress_integer;
    
23. 
    
24. 
    
25. //  以下为压缩方式存储的读处理
    
26. //  返回值就是取到的长度数据, chars_in[0]就是实际低位数据长度
    
27. unsigned long Compress_integer::get_ulong( const unsigned char *chars_in  )
    
28. {
    
29.   unsigned int  uint_char_length  = chars_in[0];
    
30.   if( uint_char_length==0 )   return 0;
    
31.   if( uint_char_length>sizeof( unsigned long) )  {
    
32.     std::string  str_msg = "compress ulong length should be ";
    
33.     str_msg += std::to_string( sizeof( unsigned long) );
    
34.     str_msg += ". but uint_char_length=";
    
35.     str_msg += std::to_string( uint_char_length );
    
36.     error_message_str( str_msg );
    
37.     return 0;
    
38.     }
    
39. 
    
40.   Union_long   union1;
    
41.   union1.ulong1 = 0;   //  先清零
    
42.   for( unsigned int i=0; i<uint_char_length; ++i )  {
    
43.     union1.uchars[i] = chars_in[i+1];
    
44.     continue;
    
45.     }
    
46.   return   union1.ulong1;
    
47. }
    
48. 
    
49. 
    
50. unsigned int Compress_integer::get_uint( const unsigned char *chars_in  )
    
51. {
    
52.   unsigned int  uint_char_length  = chars_in[0];
    
53.   if( uint_char_length==0 )   return 0;
    
54.   if( uint_char_length>sizeof( unsigned int) )  {
    
55.     std::string  str_msg = "compress uint length should be ";
    
56.     str_msg += std::to_string( sizeof( unsigned int) );
    
57.     str_msg += ". but uint_char_length=";
    
58.     str_msg += std::to_string( uint_char_length );
    
59.     error_message_str( str_msg );
    
60.     return 0;
    
61.     }
    
62.   Union_int   union1;
    
63.   union1.uint1 = 0;   //  先清零
    
64.   for( unsigned int i=0; i<uint_char_length; ++i )  {
    
65.     union1.uchars[i] = chars_in[i+1];
    
66.     continue;
    
67.     }
    
68.   return  union1.uint1;
    
69. }
    
70. 
    
71. 
    
72. unsigned short Compress_integer::get_ushort( const unsigned char *chars_in  )
    
73. {
    
74.   unsigned int  uint_char_length  = chars_in[0];
    
75.   if( uint_char_length==0 )   return 0;
    
76.   if( uint_char_length> sizeof( unsigned short ) )  {
    
77.     std::string  str_msg = "compress ushort length should be ";
    
78.     str_msg += std::to_string( sizeof( unsigned short) );
    
79.     str_msg += ". but uint_char_length=";
    
80.     str_msg += std::to_string( uint_char_length );
    
81.     error_message_str( str_msg );
    
82.     return 0;
    
83.     }
    
84.   Union_short   union1;
    
85.   union1.ushort1 = 0;   //  先清零
    
86.   for( unsigned int i=0; i<uint_char_length; ++i )  {
    
87.     union1.uchars[i] = chars_in[i+1];
    
88.     continue;
    
89.     }
    
90.   return   union1.ushort1;
    
91. }
    
92. 
    
93. 
    
94. //   生成压缩的ulong, chars_out1要预先留下9个字节, 使用1--9字节, 多数情况下只使用2个字节
    
95. //   返回chars_out生成的总长度
    
96. unsigned int  Compress_integer::make_out( const unsigned long ulong_in, unsigned char *chars_out  )
    
97. {
    
98.   if( 0==ulong_in )  {
    
99.     chars_out[0] = 0;
    
100.     return 1;
     
101.     }
     
102. 
     
103.   unsigned int int_char_length = 0;
     
104.   const unsigned char *chars_in = reinterpret_cast<const unsigned char*>( &ulong_in );
     
105.   int n = sizeof( ulong_in );
     
106.   for( int i=n-1; i>=0; --i )  {
     
107.     if( '\0'  == chars_in[i] )  continue;  //  最高位连续的'\0', 则跳过
     
108.     for( int j=0; j<=i; ++j )  {  // 拷贝非零的低位
     
109.       chars_out[j+1] = chars_in[j];
     
110.       ++int_char_length;
     
111.       continue;
     
112.       }
     
113.     break;
     
114.     }
     
115.   chars_out[0] = int_char_length;  //  第1个字节表示长度
     
116.   ++int_char_length;
     
117.   return  int_char_length;
     
118. }
     
119. 
     
120. 
     
121. //   生成压缩的uint, chars_out1要预先留下5个字节, 使用1--5字节, 多数情况下只使用2个字节
     
122. //   返回chars_out生成的总长度
     
123. unsigned int   Compress_integer::make_out( const unsigned int uint_in, unsigned char *chars_out  )
     
124. {
     
125.   if( 0==uint_in )  {
     
126.     chars_out[0] = 0;
     
127.     return 1;
     
128.     }
     
129. 
     
130.   unsigned int int_char_length = 0;
     
131.   const unsigned char *chars_in = reinterpret_cast<const unsigned char*>( &uint_in );
     
132.   int n = sizeof( uint_in );
     
133.   for( int i=n-1; i>=0; --i )  {
     
134.     if( '\0'  == chars_in[i] )  continue;  //  最高位连续的'\0', 则跳过
     
135.     for( int j=0; j<=i; ++j )  {  // 拷贝非零的低位
     
136.       chars_out[j+1] = chars_in[j];
     
137.       ++int_char_length;
     
138.       continue;
     
139.       }
     
140.     break;
     
141.     }
     
142.   chars_out[0] = int_char_length;  //  第1个字节表示长度
     
143.   ++int_char_length;
     
144.   return  int_char_length;
     
145. }
     
146. 
     
147. 
     
148. //   生成压缩的ushort, chars_out1要预先留下3个字节, 使用1--3字节, 多数情况下只使用2个字节
     
149. //   返回chars_out生成的总长度
     
150. unsigned int   Compress_integer::make_out( const unsigned short ushort_in, unsigned char *chars_out  )
     
151. {
     
152.   if( 0==ushort_in )  {
     
153.     chars_out[0] = 0;
     
154.     return 1;
     
155.     }
     
156. 
     
157.   unsigned int int_char_length = 0;
     
158.   const unsigned char *chars_in = reinterpret_cast<const unsigned char*>( &ushort_in );
     
159.   int n = sizeof( ushort_in );
     
160.   for( int i=n-1; i>=0; --i )  {
     
161.     if( '\0'  == chars_in[i] )  continue;  //  最高位连续的'\0', 则跳过
     
162.     for( int j=0; j<=i; ++j )  {  // 拷贝非零的低位
     
163.       chars_out[j+1] = chars_in[j];
     
164.       ++int_char_length;
     
165.       continue;
     
166.       }
     
167.     break;
     
168.     }
     
169.   chars_out[0] = int_char_length;  //  第1个字节表示长度
     
170.   ++int_char_length;
     
171.   return  int_char_length;
     
172. }
     
173. 
     
174. 
     
175. //  这个是写程序的时候, 写的测试程序, 用于测试验证代码的正确性.  实际测试正常.
     
176. //  测试程序有利于编写高质量的代码, 并且可以在集成测试前, 测试模块的正确性.  也便于验证版本升级等 代码修改后的正确性.
     
177. int  Compress_integer::self_test( void )
     
178. {
     
179.   unsigned long ulong1;
     
180.   unsigned int  uint1;
     
181.   unsigned int  uint_ret;
     
182.   unsigned int  uint_tmp;
     
183.   unsigned short ushort1;
     
184.   std::string   str_msg;
     
185.   std::vector<unsigned char>  vt_char;
     
186.   vt_char.resize( 100, '\0' );
     
187. 
     
188.   ulong1 = 65535;
     
189.   uint_ret = make_out( ulong1, &vt_char[0] );
     
190.   if( uint_ret != 3 || vt_char[0] != 2 || vt_char[1] != 255 || vt_char[2] != 255 )  {
     
191.     str_msg = "make_out( const unsigned long ulong_in, char *chars_out  );    test failed. ";
     
192.     str_msg += ", uint_ret=";
     
193.     str_msg += std::to_string( uint_ret );
     
194.     str_msg += ", vt_char[0]=";
     
195.     uint_tmp = vt_char[0];
     
196.     str_msg +=  std::to_string( uint_tmp );
     
197.     str_msg += ", vt_char[1]=";
     
198.     uint_tmp = vt_char[1];
     
199.     str_msg +=  std::to_string( uint_tmp );
     
200.     str_msg += ", vt_char[2]=";
     
201.     uint_tmp = vt_char[2];
     
202.     str_msg +=  std::to_string( uint_tmp );
     
203.     error_message_str( str_msg );
     
204.     return -1;
     
205.     }
     
206.   ulong1 = get_ulong( &vt_char[0] );
     
207.   if( ulong1 != 65535 )  {
     
208.     error_message( "static  unsigned long  get_ulong( const char *chars_in  );    test failed. ");
     
209.     return -2;
     
210.     }
     
211. 
     
212.   ulong1 = 65536;
     
213.   uint_ret = make_out( ulong1, &vt_char[0] );
     
214.   if( uint_ret != 4 ) {
     
215.     str_msg = "uint_ret != 4,   uint_ret=";
     
216.     str_msg += std::to_string( uint_ret );
     
217.     error_message_str( str_msg );
     
218.     return -3;
     
219.     }
     
220.   ulong1 = get_ulong( &vt_char[0] );
     
221.   if( ulong1 != 65536 )  {
     
222.     error_message( "static  unsigned long  get_ulong( const char *chars_in  );    test failed. ");
     
223.     return -2;
     
224.     }
     
225. 
     
226.   ulong1 = 3;
     
227.   uint_ret = make_out( ulong1, &vt_char[0] );
     
228.   if( uint_ret != 2 || vt_char[0] != 1 || vt_char[1] != 3  )  {
     
229.     error_message("make_out( const unsigned long ulong_in, char *chars_out  );    test failed. ");
     
230.     return -1;
     
231.     }
     
232.   ulong1 = get_ulong( &vt_char[0] );
     
233.   if( ulong1 != 3 )  {
     
234.     error_message( "static  unsigned long  get_ulong( const char *chars_in  );    test failed. ");
     
235.     return -2;
     
236.     }
     
237. 
     
238.   ulong1 = 3423732746321463216L;
     
239.   uint_ret = make_out( ulong1, &vt_char[0] );
     
240.   ulong1 = get_ulong( &vt_char[0] );
     
241.   if( ulong1 != 3423732746321463216L )  {
     
242.     error_message( "static  unsigned long  get_ulong( const char *chars_in  );    test failed. ");
     
243.     return -2;
     
244.     }
     
245. 
     
246.   uint1 = 65535;
     
247.   uint_ret = make_out( uint1, &vt_char[0] );
     
248.   if( uint_ret != 3 || vt_char[0] != 2 || vt_char[1] != 255 || vt_char[2] != 255 )  {
     
249.     str_msg = "test failed. ";
     
250.     str_msg += ", uint_ret=";
     
251.     str_msg += std::to_string( uint_ret );
     
252.     str_msg += ", vt_char[0]=";
     
253.     uint_tmp = vt_char[0];
     
254.     str_msg +=  std::to_string( uint_tmp );
     
255.     str_msg += ", vt_char[1]=";
     
256.     uint_tmp = vt_char[1];
     
257.     str_msg +=  std::to_string( uint_tmp );
     
258.     str_msg += ", vt_char[2]=";
     
259.     uint_tmp = vt_char[2];
     
260.     str_msg +=  std::to_string( uint_tmp );
     
261.     error_message_str( str_msg );
     
262.     return -1;
     
263.     }
     
264.   uint1 = get_uint( &vt_char[0] );
     
265.   if( uint1 != 65535 )  {
     
266.     error_message( " test failed. ");
     
267.     return -2;
     
268.     }
     
269. 
     
270.   uint1 = 65536;
     
271.   uint_ret = make_out( uint1, &vt_char[0] );
     
272.   if( uint_ret != 4 ) {
     
273.     str_msg = "uint_ret != 4,   uint_ret=";
     
274.     str_msg += std::to_string( uint_ret );
     
275.     error_message_str( str_msg );
     
276.     return -3;
     
277.     }
     
278.   uint1 = get_uint( &vt_char[0] );
     
279.   if( uint1 != 65536 )  {
     
280.     error_message( "test failed. ");
     
281.     return -2;
     
282.     }
     
283. 
     
284.   uint1 = 342373274;
     
285.   uint_ret = make_out( uint1, &vt_char[0] );
     
286.   uint1 = get_uint( &vt_char[0] );
     
287.   if( uint1 !=  342373274 )  {
     
288.     error_message( "test failed. ");
     
289.     return -2;
     
290.     }
     
291. 
     
292.   ushort1 = 65535;
     
293.   uint_ret = make_out( ushort1, &vt_char[0] );
     
294.   if( uint_ret != 3 || vt_char[0] != 2 || vt_char[1] != 255 || vt_char[2] != 255 )  {
     
295.     str_msg = "test failed. ";
     
296.     str_msg += ", uint_ret=";
     
297.     str_msg += std::to_string( uint_ret );
     
298.     str_msg += ", vt_char[0]=";
     
299.     uint_tmp = vt_char[0];
     
300.     str_msg +=  std::to_string( uint_tmp );
     
301.     str_msg += ", vt_char[1]=";
     
302.     uint_tmp = vt_char[1];
     
303.     str_msg +=  std::to_string( uint_tmp );
     
304.     error_message_str( str_msg );
     
305.     return -1;
     
306.     }
     
307.   ushort1 = get_ushort( &vt_char[0] );
     
308.   if( ushort1 != 65535 )  {
     
309.     error_message( " test failed. ");
     
310.     return -2;
     
311.     }
     
312. 
     
313.   ushort1 = 53274;
     
314.   uint_ret = make_out( ushort1, &vt_char[0] );
     
315.   ushort1 = get_ushort( &vt_char[0] );
     
316.   if( ushort1 != 53274 )  {
     
317.     error_message( "test failed. ");
     
318.     return -2;
     
319.     }
     
320. 
     
321.   return 0;
     
322. }
     
323. 
     
324. #endif  // _compress_integer_hpp
     
325. 
     

复制代码

BetonArmEE

wlmqgzm 发表于 2016-05-25 22:33
下面是做的unsigned long long, unsigned int 压缩程序,  大约可以压缩一半的字节数,
这部分代码的压缩原理 ...

和Google的protobuf、我的DirectStruct思路差不多

wlmqgzm

回复 54# BetonArmEE

对,     这部分整数压缩思路算是很多公司的新型接口都采用了.      ,  所以, 开源出来,

最近一两周代码中, 实现的 Wait_free, Lock_free 通用对象队列,  算的上技术含金量最高的, 使用了模板技术等, 性能上算彻底突破锁的瓶颈,

以前虽然利用Lock_free_queue做了一些代码, 主要是利用Boost的lock_free队列,只能适合POD对象, 从未自己实现过通用对象的Wait_free/Lock_free Queue,
这次实现了任意对象的Wait_free_queue, 算是对Boost库的拓展, 如果提交的话, 估计有进入Boost库代码的潜力.

主要的技术难点是:
1) shared_ptr对象在pop前需要保存起来, 以便实现 生产者 Fire and care nothing 发射后就不管了,   等消费者pop处理完毕, shared_ptr对象要自动释放.
2)生产者临时存放shared_ptr的对象, 无论是采用deque, list, 还是其他vector对象, 都不是线程安全的, 这里不能使用锁, 否则, 无锁队列就没有意义了.  那么这部分代码是如何在无锁的前提下无冲突安全工作的?
这些都是容易产生坑的地方, 那么就要想出来办法, 完全消灭这些坑.
3) 消费者pop消费掉对象后,  生产者临时存放shared_ptr的对象需要释放,  如何实现?
不能再创建一个队列反向通知, 这样的效率太低了, 那么, 一个单向队列, 如何让对端知道一些对象已经可以释放? 还不能释放已经pop, 但是正在处理的对象, 因此, 也不能完全依赖环形队列自身.
也不能依赖shared_ptr,   因为真正最底层的Wait_free队列最多只能存放64位整数(指针), shared_ptr本身就根本无法存放进Wait_free队列, 我的代码中实际实现在最底层Wait_free队列中传递的是shared_ptr保存对象的指针
为了实现 Wait_free, 生产者和消费者还不能有共享变量, 例如: 共享atomic,  否则, 就变成Lock_free了

总之, 封装实现一个任意对象的Lock_free / Wait_free 队列技术难度很高, 就是将上述的各个大坑全部填平, 然后拿出一套完整的解决办法.
就是因为目前已有的开源技术, 没有一家能够实现的, 所以, Boost目前没有提供通用对象的Lock_free/Wait_free队列.
实际上, 通用对象的Lock_free/Wait_free队列, 在实际开发中才是真正需要的, 各大公司就算有弄出来的, 基本都视为核心代码, 予以保密. 这个是解决高并发下高性能的核武器级别的开发辅助工具包. 对性能提升帮助是非常大的.

wlmqgzm

最近代码开发速度比较慢, 每天只有数百行, , 这样的话, 这个项目有可能要花更多的时间才能出第一个版本,

fender0107401

wlmqgzm 发表于 2016-05-26 10:46
最近代码开发速度比较慢, 每天只有数百行, , 这样的话, 这个项目有可能要花更多的时间才能出第一个版本, ...

要是都有用的话，每天数百行已经不少了。

windoze

回复 55# wlmqgzm

谁告诉你Boost.Lockfree只支持POD？
http://www.boost.org/doc/libs/1_61_0/doc/html/lockfree.html

另外再提醒你一下，new和delete不是lockfree的。

wlmqgzm

回复 58# windoze

  boost::lockfree::queue<int>    d_lock_free_queue1(100);
  if( d_lock_free_queue1.is_lock_free() )  {
    std::cout<< "1 is lock_free!" <<std::endl;
    }
  else   std::cout<< "1 NOT lock_free!" <<std::endl;

  boost::lockfree::queue<std::shared_ptr<int> >    d_lock_free_queue2(100);
  if( d_lock_free_queue2.is_lock_free() )  {
    std::cout<< "2 is lock_free!" <<std::endl;
    }
  else   std::cout<< "2 NOT lock_free!" <<std::endl;


||=== Build: Release in mysql1 (compiler: GNU GCC Compiler) ===|
/usr/include/boost/lockfree/queue.hpp||In instantiation of ‘class boost::lockfree::queue<std::shared_ptr<int> >’
/var/cpp/mysql2/main.cpp|187|required from here|
/usr/include/boost/lockfree/queue.hpp|87|error: static assertion failed: (boost::has_trivial_destructor<T>::value)|
/usr/include/boost/lockfree/queue.hpp|91|error: static assertion failed: (boost::has_trivial_assign<T>::value)|
||=== Build failed: 2 error(s), 2 warning(s) (0 minute(s), 3 second(s)) ===|

实际就是编译无法通过, boost::lockfree::queue目前不支持shared_ptr

   

wlmqgzm

回复 58# windoze

引用 译文: http://blog.csdn.net/chen19870707/article/details/40039401

TCMalloc:线程缓冲的Malloc

TCMalloc的版本同样的操作大约只需要50纳秒。

TCMalloc也减少了多线程程序中的锁竞争情况。对于小对象，已经基本上达到了零竞争。对于大对象，TCMalloc尝试使用恰当粒度和有效的自旋锁。

........如果自由列表不空，那么从移除列表的第一个对象并返回它。当按照这个快速通道时，TCMalloc不会获取任何锁。这就可以极大提高分配的速度，因为锁/解锁操作在一个2.8GHz Xeon上大约需要100纳秒的时间。

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

我的理解: 内存申请有时是存在锁的问题, 多数时候是不用锁的, 因为TCMalloc是基于线程预分配内存的, 只有预分配的内存用完的情况下, 才会申请锁, 申请更多的内存, 小概率" 有锁, 有等待",
这个部分Google的TCMalloc基本已经做的挺好.

确实是高手啊, 这个是Lock_free Wait_free代码里面唯一出现锁(小概率)的地方,  也不是没有彻底解决小概率锁的办法, 就是不够优雅, 例如: 自定义一个足够空间的Malloc, 这部分代码只能从这个空间申请和释放内存, 与其他代码隔离开,