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

wlmqgzm

回复 69# windoze

这里没有memory management thread, 如果有的话, 可能是TCMalloc的. 但是前面也说了, TCMalloc多数情况下, 不需要与TCMalloc其他线程交互, 也不需要锁.

还是以简单的单生产者单消费者Wait_free_queue为例子, 这里永远只有2个线程, 代码中不存在第3个线程, 也不会创建第3个线程, 也没有第3个线程, 永远是单生产者线程负责内存的申请和释放, 只有这一个线程与内存申请释放有关, 消费者线程与内存管理毫无关系, 生产者线程 push代码内部申请本次push需要的小内存后, 有检查确认是否需要释放以前申请的内存; 未来第N次push的时候, 生产者线程在push代码内部检查代码判断符合条件, 释放这次申请的内存.  

Lock_free_queue内存管理设计的原则很简单, 就是: 哪个线程申请的内存, 由哪个线程负责释放, 不与其他线程协调.


   

windoze

回复 70# wlmqgzm

想清楚再下结论，如果producer thread分配了一块内存，传递给了consumer thread去处理，按你“谁分配谁释放”的说法，producer thread什么时候才知道自己需要释放这块内存？无论如何得等到consumer处理完之后才行对不？那么producer怎么才能知道consumer处理完了？你总不能再建一个queue让consumer反过来通知producer吧。

按照你的设计，跨thread的内存管理不但不能避免，甚至还会加剧，TCMalloc根本就帮不上你什么忙。

其实你完全不需要解释的，你自己用strace看一下TCMalloc里加锁解锁的次数统计就知道了。

hellioncu

对于这种服务器应用，关注的应该是吞吐量而不是每笔响应时间，应在设计上尽量避免锁的竞争，提高并发能力。无锁实现往往会是一个坑，追求无锁意义不大。

cokeboL

如果可以无锁，那当初锁就不会被设计出来。。

wlmqgzm

回复 72# windoze

producer thread什么时候才知道自己需要释放这块内存？
前面我说了, 一般人都绕不过这个弯子, 总觉得无法实现, 就是有一点点微创新, 以单生产者单消费者为例, 2个计数器就足够了, 为什么是2个, 是为了无等待






   

wlmqgzm

//  本段代码主要是压缩日期和时间为整数, 结合前面给出的整数压缩编码的方案, 可以用更少的字节数,  最终实现更高效率的存储
//  综合考虑,  如果直接使用日期和时间等各C++对象, 效率不高,, 最终还是要自己做代码来提高性能,
//  因此, 干脆直接全部使用自己的代码来实现, 总体上以效率为准

//  方案一: 年9999, 可以用2个字节,最大到65535,  月12用1个字节, 日31用一个字节, 这样总共4个字节, 中间不做转换,效率最高
//   通用代码来实现, 这样1个整数, 4个字节, 头2个字节就是年, 后1个字节就是月, 最后一个字节就是日, 简单的substr操作就可以.
//  方案二:  20160424整体作为整数, 除以10000就是年, 余数0424, 再除以100就是月4, 余数就是日24, 这个方案最大可表示20万年
//  方案三: 2016, 04, 24 整数=2016*12*31+4*31 + 24,   除以12*31=年份,余数部分除以31就是4月,余数就是24日,这个方案表示的年份最大
//  方案四: 直接用离1970/01/01的Unix日子来表示, 这个主要的优点是计算方便,可以不用转换,直接计算, 缺点是输出的时候(这个是最常用的功能), 计算比较繁琐,性能低
//  综合考虑下来, 就采用方案3来存放, 一般的大小比较可以直接比较,  其他的日期计算的就需要转化,

//  这里不得不用如此多的代码来实现的一个原因是: 对现有的代码表示的日期范围不满意
//  将一个字符串表示的日期, "20160120", "2016/1/29", "2016-1-24"这样类似的三种格式统一转化为一个32位的整数
//  最大可以表示11545611年, 即1154万年以后的情况
//  出错返回0, 其他返回一个大于零的整数
//  允许的日期从0000/01/01开始, 到11545611/12/31为止

1. 
   
2. //  判断是否是闰年
   
3. bool year_is_leap( unsigned int int_year )
   
4. {
   
5.   if( int_year%400==0 )   return true;
   
6.   if( int_year%100==0 )   return false;
   
7.   if( int_year%4==0 )       return true;
   
8.   return false;
   
9. }
   
10. 
    
11. 
    
12. unsigned int string_to_uint_date( const std::string &str_in, std::string &str_error )
    
13. {
    
14.   unsigned int  uint_year;
    
15.   unsigned int  uint_month;
    
16.   unsigned int  uint_day;
    
17.   std::string str_tmp;
    
18.   std::string str_cmp;
    
19.   std::vector<std::string>  vt_str_out;
    
20.   std::string str_year;
    
21.   std::string str_month;
    
22.   std::string str_day;
    
23.   std::vector<unsigned int>vt_int_day = {31,29,31,30,31,30,   31,31,30,31,30,31 };
    
24.   std::vector<std::string>vt_str_month1 = { "Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec" };
    
25.   std::vector<std::string>vt_str_month2 = { "JAN","FEB","MAR","APR","MAY","JUN","JUL","AUG","SEP","OCT","NOV","DEC" };
    
26.   bool bool_has_abc ;
    
27. 
    
28.   str_error.clear();
    
29.   unsigned int n = str_in.length();
    
30.   if( n < 6 )  {
    
31.     str_error   = str_in;
    
32.     str_error += " is too short.";
    
33.     return 0;
    
34.     }
    
35. 
    
36.   //  获得特殊字符, 存放到str_cmp;  可以支持- / _等情况
    
37.   for( unsigned int i=0; i<n; ++i )  {
    
38.     str_tmp = str_in.substr( i, 1 );
    
39.     if( str_tmp>="0" && str_tmp<="9" )  continue;
    
40.     str_cmp = str_tmp;
    
41.     break;
    
42.     }
    
43. 
    
44.   //  检查是否存在字母
    
45.   bool_has_abc = string_has_abc( str_in );
    
46.   if( str_cmp.empty()  )  {  //  表示没有特殊字符隔离, 说明全部是数字
    
47.     if( bool_has_abc )  {   //  如果没有特殊字符隔离又有字母, 出错
    
48.       str_error   = str_in;
    
49.       str_error += " has abc and no find - or /.";
    
50.       return 0;
    
51.       }
    
52.     // 表示没有特殊字符隔离, 没有字母, 说明全部是数字
    
53.     str_year = str_in.substr( 0, str_in.length()-4 );  //  保留除最后4位的就是年
    
54.     str_month = str_in.substr( str_in.length()-4, 2 );  //  保留最后4位开始的2字节就是月
    
55.     str_day = str_in.substr( str_in.length()-2, 2 );  // 最后2位是日
    
56.     }
    
57.   else  {
    
58.     string_to_vector_string(  str_in,  str_cmp, vt_str_out  );
    
59.     if(  vt_str_out.size()>3) {
    
60.       str_error   = str_in;
    
61.       str_error += " has too many data.";
    
62.       return 0;
    
63.       }
    
64.     if( 3==vt_str_out.size() )  {
    
65.       str_year = vt_str_out[0];
    
66.       str_month = vt_str_out[1];
    
67.       str_day = vt_str_out[2];
    
68.       if( bool_has_abc )   {  //  如果有字母,  则转换字母月份到数字月份
    
69.         for( unsigned int i=0, n=12; i<n; ++i )  {
    
70.           if( vt_str_month1[i]  != str_month && vt_str_month2[i]  != str_month )  continue;
    
71.           str_month = std::to_string( i+1 );
    
72.           continue;
    
73.           }
    
74.         }
    
75.       }
    
76.     }
    
77. 
    
78. if( str_year.empty() || str_year.length()>8  || !string_is_number( str_year )  )     {
    
79.    str_error  = "str_in=";
    
80.    str_error += str_in;
    
81.    str_error +=  ", str_year=";
    
82.    str_error += str_year;
    
83.    str_error += ", year is bad.";
    
84.    return 0;
    
85.    }
    
86. if( str_month.empty() || str_month.length()>2  || !string_is_number( str_month ) )     {
    
87.    str_error  = "str_in=";
    
88.    str_error += str_in;
    
89.    str_error +=  ", str_month=";
    
90.    str_error += str_month;
    
91.    str_error += ", month is bad.";
    
92.    return 0;
    
93.    }
    
94.   if( str_day.empty() || str_month.length()>2  || !string_is_number( str_day ) )     {
    
95.    str_error  = "str_in=";
    
96.    str_error += str_in;
    
97.    str_error +=  ", str_day=";
    
98.    str_error += str_day;
    
99.    str_error += ", day is bad.";
    
100.    return 0;
     
101.    }
     
102. 
     
103. uint_year = boost::lexical_cast<unsigned int>( str_year );
     
104. if( uint_year>256L*256*256*256/12/31 )  {
     
105.    str_error   = str_in;
     
106.    str_error += ", year is error.";
     
107.    return 0;
     
108.    }
     
109.   uint_month = boost::lexical_cast<unsigned int>( str_month );
     
110.   if( uint_month<1 || uint_month>12 )  {
     
111.     str_error   = str_in;
     
112.     str_error += ", month is error.";
     
113.     return 0;
     
114.     }
     
115.   uint_day = boost::lexical_cast<unsigned int>( str_day );
     
116.   if( uint_day<1 || uint_day>31 )  {
     
117.     str_error   = str_in;
     
118.     str_error += ", day is error.";
     
119.     return 0;
     
120.     }
     
121. 
     
122.   if( 2==uint_month )  {   //  处理特殊的2月
     
123.     if( !year_is_leap( uint_year ) &&  uint_day==29 )  {  // 非闰年有29日的报错
     
124.       str_error   = str_in;
     
125.       str_error += ", day is error. not a leapyear. day can not be 29 in this month.";
     
126.       return 0;
     
127.       }
     
128.     }
     
129.   if( uint_day > vt_int_day[uint_month-1] ) {
     
130.     str_error   = str_in;
     
131.     str_error += ", day is error. max day in this month is ";
     
132.     str_error += std::to_string( vt_int_day[uint_month-1] );
     
133.     return 0;
     
134.     }
     
135. 
     
136.   return uint_year*12*31 + uint_month*31 + uint_day;
     
137. }
     
138. 
     
139. 
     
140. unsigned int ymd_to_uint_date( const unsigned int  uint_year,  const unsigned int  uint_month,  const unsigned int uint_day, std::string &str_error )
     
141. {
     
142.   std::vector<unsigned int>vt_int_day = {31,29,31,30,31,30,   31,31,30,31,30,31 };
     
143. 
     
144.   if( uint_year>256L*256*256*256/12/31 )  {
     
145.     str_error = "year is error. year=";
     
146.     str_error += std::to_string( uint_year );
     
147.     return 0;
     
148.     }
     
149.   if( uint_month<1 || uint_month>12 )  {
     
150.     str_error = "month is error. month=";
     
151.     str_error += std::to_string( uint_month );
     
152.     return 0;
     
153.     }
     
154.   if( uint_day<1 || uint_day>31 )  {
     
155.     str_error = "day is error. day=";
     
156.     str_error += std::to_string( uint_day );
     
157.     return 0;
     
158.     }
     
159. 
     
160.   if( 2==uint_month )  {   //  处理特殊的2月
     
161.     if( !year_is_leap( uint_year ) &&  uint_day==29 )  {  // 非闰年有29日的报错
     
162.       str_error = "day is error. not a leapyear. year=";
     
163.       str_error += std::to_string( uint_year );
     
164.       str_error += ", month=";
     
165.       str_error += std::to_string( uint_month );
     
166.       str_error += ", day=";
     
167.       str_error += std::to_string( uint_day );
     
168.       return 0;
     
169.       }
     
170.     }
     
171.   if( uint_day > vt_int_day[uint_month-1] ) {
     
172.     str_error = "day is error. max day in this month is ";
     
173.     str_error += std::to_string( vt_int_day[uint_month-1] );
     
174.     str_error += ", month=";
     
175.     str_error += std::to_string( uint_month );
     
176.     str_error += ", day=";
     
177.     str_error += std::to_string( uint_day );
     
178.     return 0;
     
179.     }
     
180. 
     
181.   return uint_year*12*31 + uint_month*31 + uint_day;
     
182. }
     
183. 
     
184. 
     
185. 
     
186. void uint_date_to_string( const unsigned int uint_date,  std::string &str_date )
     
187. {
     
188.   unsigned int  uint_year;
     
189.   unsigned int  uint_month;
     
190.   unsigned int  uint_day;
     
191.   unsigned int  uint_excess;  //  余数
     
192.   std::string  str_year;
     
193.   std::string  str_month;
     
194.   std::string  str_day;
     
195.   std::string  str_tmp;
     
196. 
     
197.   uint_year = uint_date / 372;  // 12*31=372
     
198.   uint_excess = uint_date % 372;
     
199.   uint_month = uint_excess / 31;
     
200.   uint_day = uint_excess % 31;
     
201. 
     
202.   str_year = std::to_string( uint_year );
     
203.   str_month = std::to_string( uint_month );
     
204.   str_day = std::to_string( uint_day );
     
205. 
     
206.   /* std::cout << "str_year=" <<  str_year  << std::endl;
     
207.   std::cout << "str_month=" <<  str_month  << std::endl;
     
208.   std::cout << "str_day=" <<  str_day  << std::endl; */
     
209. 
     
210.   while( str_year.length()<4 )  {
     
211.     str_tmp = "0";
     
212.     str_tmp += str_year;
     
213.     str_year = str_tmp;
     
214.     }
     
215.   if( str_month.length()<2 )  {
     
216.     str_tmp = "0";
     
217.     str_tmp += str_month;
     
218.     str_month = str_tmp;
     
219.     }
     
220.   if( str_day.length()<2 )  {
     
221.     str_tmp = "0";
     
222.     str_tmp += str_day;
     
223.     str_day = str_tmp;
     
224.     }
     
225.   str_date = str_year ;
     
226.   str_date += "-";
     
227.   str_date += str_month;
     
228.   str_date += "-";
     
229.   str_date += str_day;
     
230.   std::cout << str_date << std::endl << std::endl;
     
231.   return;
     
232. }
     
233. 
     
234. 
     
235. void uint_date_to_ymd( const unsigned int uint_date,  unsigned int  &uint_year,  unsigned int  &uint_month,  unsigned int &uint_day  )
     
236. {
     
237.   unsigned int  uint_excess;  //  余数
     
238.   std::string  str_year;
     
239.   std::string  str_month;
     
240.   std::string  str_day;
     
241.   std::string  str_tmp;
     
242. 
     
243.   uint_year = uint_date / 372;  // 12*31=372
     
244.   uint_excess = uint_date % 372;
     
245.   uint_month = uint_excess / 31;
     
246.   uint_day = uint_excess % 31;
     
247.   return;
     
248. }
     
249. 
     
250. 
     
251. //  将一个字符串转化为一个整数, 表示从00:00:00过的秒数
     
252. unsigned int string_to_uint_time( const std::string &str_in, std::string &str_error )
     
253. {
     
254.   unsigned int  uint_hour;
     
255.   unsigned int  uint_minute;
     
256.   unsigned int  uint_second;
     
257.   std::string str_tmp;
     
258.   std::string str_cmp;
     
259.   std::string str_hour;
     
260.   std::string str_minute;
     
261.   std::string str_second;
     
262.   std::vector<std::string>  vt_str_out;
     
263. 
     
264.   str_error.clear();
     
265.   unsigned int n = str_in.length();
     
266.   if( n < 6 )  {
     
267.     str_error   = str_in;
     
268.     str_error += " is too short.";
     
269.     return 0;
     
270.     }
     
271. 
     
272.   //  获得特殊字符, 存放到str_cmp;  可以支持- / _等情况
     
273.   for( unsigned int i=0; i<n; ++i )  {
     
274.     str_tmp = str_in.substr( i, 1 );
     
275.     if( str_tmp>="0" && str_tmp<="9" )  continue;
     
276.     str_cmp = str_tmp;  //  获取第1个非数字的字符
     
277.     break;
     
278.     }
     
279. 
     
280.   if( string_has_abc( str_in ) )  {   //  如果有字母, 出错
     
281.     str_error   = str_in;
     
282.     str_error += " , time must not have abc.";
     
283.     return 0;
     
284.     }
     
285.   if( str_cmp.empty() )  {  //
     
286.     str_hour = str_in.substr( 0, 2 );  //
     
287.     str_minute = str_in.substr( 2, 2 );  //
     
288.     str_second = str_in.substr( 4, 2 );  //
     
289.     }
     
290.   else  {
     
291.     string_to_vector_string(  str_in,  str_cmp, vt_str_out  );
     
292.     if(  vt_str_out.size()>3) {
     
293.       str_error   = str_in;
     
294.       str_error += " has too many data.";
     
295.       return 0;
     
296.       }
     
297.     if( 3==vt_str_out.size() )  {
     
298.       str_hour = vt_str_out[0];
     
299.       str_minute = vt_str_out[1];
     
300.       str_second = vt_str_out[2];
     
301.       }
     
302.     }
     
303. 
     
304. if(  str_hour.length() != 2  || !string_is_number( str_hour )  )     {
     
305.    str_error  = "str_in=";
     
306.    str_error += str_in;
     
307.    str_error +=  ", str_hour=";
     
308.    str_error += str_hour;
     
309.    str_error += ", hour is bad.";
     
310.    return 0;
     
311.    }
     
312. if( str_minute.length() != 2  || !string_is_number( str_minute ) )     {
     
313.    str_error  = "str_in=";
     
314.    str_error += str_in;
     
315.    str_error +=  ", str_minute=";
     
316.    str_error += str_minute;
     
317.    str_error += ", minute is bad.";
     
318.    return 0;
     
319.    }
     
320.   if( str_second.length() != 2  || !string_is_number( str_second ) )     {
     
321.    str_error  = "str_in=";
     
322.    str_error += str_in;
     
323.    str_error +=  ", str_second=";
     
324.    str_error += str_second;
     
325.    str_error += ", second is bad.";
     
326.    return 0;
     
327.    }
     
328. 
     
329. std::cout << "hour=" << str_hour  << std::endl;
     
330. std::cout << "minute=" << str_minute  << std::endl;
     
331. std::cout << "second=" << str_second  << std::endl;
     
332. 
     
333. uint_hour = boost::lexical_cast<unsigned int>( str_hour );
     
334. if( uint_hour>23 )  {
     
335.    str_error   = str_in;
     
336.    str_error += ", hours must below 24.";
     
337.    return 0;
     
338.    }
     
339.   uint_minute = boost::lexical_cast<unsigned int>( str_minute );
     
340.   if( uint_minute>60 )  {
     
341.     str_error   = str_in;
     
342.     str_error += ", minutes must below 60.";
     
343.     return 0;
     
344.     }
     
345.   uint_second = boost::lexical_cast<unsigned int>( str_second );
     
346.   if( uint_second>60 )  {
     
347.     str_error   = str_in;
     
348.     str_error += ", seconds must below 60.";
     
349.     return 0;
     
350.     }
     
351. 
     
352.   return uint_hour*3600 + uint_minute*60 + uint_second;
     
353. }
     
354. 
     
355. 
     
356. unsigned long string_to_ulong_datetime( const std::string &str_in, std::string &str_error )
     
357. {
     
358.   unsigned long ulong_date;
     
359.   unsigned long ulong_time;
     
360.   std::string  str_date;
     
361.   std::string  str_time;
     
362.   std::vector<std::string>  vt_str_out;
     
363.   std::string str_cmp = " ";
     
364.   string_to_vector_string(  str_in,  str_cmp, vt_str_out  );
     
365.   if(  vt_str_out.size()>2) {
     
366.     str_error   = str_in;
     
367.     str_error += " has too many blank.";
     
368.     return 0;
     
369.     }
     
370.   if( 2==vt_str_out.size() )  {
     
371.     str_date = vt_str_out[0];
     
372.     str_time = vt_str_out[1];
     
373.     }
     
374.   ulong_date = string_to_uint_date( str_date, str_error );
     
375.   if( !str_error.empty() )  return 0;
     
376.   ulong_time = string_to_uint_time( str_time, str_error );
     
377.   if( !str_error.empty() )  return 0;
     
378.   //ulong_ret = ulong_date * 86400L + ulong_time;
     
379.   return ulong_date * 86400L + ulong_time;
     
380. }
     
381. 
     
382. 
     
383. void uint_time_to_string( const unsigned int uint_time,  std::string &str_time )
     
384. {
     
385.   unsigned int  uint_hour;
     
386.   unsigned int  uint_minute;
     
387.   unsigned int  uint_second;
     
388.   unsigned int  uint_excess;  //  余数
     
389.   std::string  str_hour;
     
390.   std::string  str_minute;
     
391.   std::string  str_second;
     
392.   std::string  str_tmp;
     
393. 
     
394.   uint_hour = uint_time / 3600;  // 12*31=372
     
395.   uint_excess = uint_time % 3600;
     
396.   uint_minute = uint_excess / 60;
     
397.   uint_second = uint_excess % 60;
     
398. 
     
399.   str_hour = std::to_string( uint_hour );
     
400.   str_minute = std::to_string( uint_minute );
     
401.   str_second = std::to_string( uint_second );
     
402. 
     
403.   /* std::cout << "str_hour=" <<  str_hour  << std::endl;
     
404.   std::cout << "str_minute=" <<  str_minute  << std::endl;
     
405.   std::cout << "str_second=" <<  str_second  << std::endl; */
     
406. 
     
407.   if( str_hour.length()<2 )  {
     
408.     str_tmp = "0";
     
409.     str_tmp += str_hour;
     
410.     str_hour = str_tmp;
     
411.     }
     
412.   if( str_minute.length()<2 )  {
     
413.     str_tmp = "0";
     
414.     str_tmp += str_minute;
     
415.     str_minute = str_tmp;
     
416.     }
     
417.   if( str_second.length()<2 )  {
     
418.     str_tmp = "0";
     
419.     str_tmp += str_second;
     
420.     str_second = str_tmp;
     
421.     }
     
422.   str_time = str_hour;
     
423.   str_time += ":";
     
424.   str_time += str_minute;
     
425.   str_time += ":";
     
426.   str_time += str_second;
     
427.   std::cout << str_time << std::endl << std::endl;
     
428.   return;
     
429. }
     
430. 
     
431. 
     
432. void ulong_datetime_to_string( const unsigned long ulong_datetime,  std::string &str_datetime )
     
433. {
     
434.   //unsigned long ulong_date;
     
435.   //unsigned long ulong_time;
     
436.   unsigned int   uint_date;
     
437.   unsigned int   uint_time;
     
438.   std::string str_date;
     
439.   std::string str_time;
     
440. 
     
441.   uint_date  = ulong_datetime / 86400L;
     
442.   uint_time  = ulong_datetime % 86400L;
     
443.   uint_date_to_string( uint_date, str_date );
     
444.   uint_time_to_string( uint_time, str_time );
     
445.   str_datetime = str_date;
     
446.   str_datetime += " ";
     
447.   str_datetime += str_time;
     
448.   return;
     
449. }
     
450. 
     
451. 
     
452. void uint_time_to_hms( const unsigned int uint_time,  unsigned int  &uint_hour, unsigned int  &uint_minute,  unsigned int  &uint_second )
     
453. {
     
454.   unsigned int  uint_excess;  //  余数
     
455.   std::string  str_hour;
     
456.   std::string  str_minute;
     
457.   std::string  str_second;
     
458.   std::string  str_tmp;
     
459. 
     
460.   uint_hour = uint_time / 3600;  // 12*31=372
     
461.   uint_excess = uint_time % 3600;
     
462.   uint_minute = uint_excess / 60;
     
463.   uint_second = uint_excess % 60;
     
464.   return;
     
465. }
     
466. 
     
467. 
     
468. void ulong_datetime_to_ymdhms( const unsigned long ulong_datetime,
     
469.   unsigned int  &uint_year,  unsigned int  &uint_month,  unsigned int &uint_day,
     
470.   unsigned int  &uint_hour, unsigned int  &uint_minute,  unsigned int &uint_second )
     
471. {
     
472.   unsigned int   uint_date;
     
473.   unsigned int   uint_time;
     
474. 
     
475.   uint_date  = ulong_datetime / 86400L;
     
476.   uint_time  = ulong_datetime % 86400L;
     
477. 
     
478.   uint_date_to_ymd( uint_date, uint_year, uint_month, uint_day );
     
479.   uint_time_to_hms( uint_time, uint_hour, uint_minute, uint_second );
     
480.   return;
     
481. }

复制代码

wlmqgzm

由于最终的版本将是一个支持大型数据库的存储层, 因此, 存储层的代码做的比较厚,不仅仅是一个KV数据库的存储层, 还是一个通用数据库存储层.
这样预计第一个版本的完成时间, 可能会延期, 但是, 毕竟是自己开发的完整软件, 早一点晚一点都无所谓, 就是希望代码能够尽量重用.

为了有效管理和压缩数据, 在存储层定义和实现了Field type,  支持下列字段类型.

enum field_type{
       field_type_unknow = 0,   
       field_type_bit,
       field_type_bool,  
       field_type_unsigned_tiny_int,
       field_type_tiny_int,
       field_type_enum,
       field_type_unsigned_smallint,
       field_type_smallint,
       field_type_unsigned_int,
       field_type_int,
       field_type_unsigned_bigint,  
       field_type_bigint,  
       field_type_float,
       field_type_double,
       field_type_decimal,
       field_type_chars,
       field_type_varchar,  
       field_type_tiny_txt,
       field_type_txt,
       field_type_medium_txt,
       field_type_big_txt,
       field_type_binary,
       field_type_varbinary,
       field_type_tiny_blob,
       field_type_blob,
       field_type_medium_blob,
       field_type_big_blob,
       field_type_date,   
       field_type_time,
       field_type_timestamp,  
       field_type_timestamp_usecond,  
       field_type_datetime,      
       field_type_datetime_usecond,  
       field_type_set
       };

wlmqgzm

继续做代码中, .......

线程规划情况:
线程数量= io_service 数量= CPU数量
在我的机器上, 网络层使用8个线程, 然后, 提供通用的命令接口层, 命令接口层是一个函数, 转换网络IO到内部函数, 然后指令被转发到 数据层.
网络层是Boost Asio的异步网络接口, 多线程驱动, 高并发设计.

数据层是多io_service 线程驱动的, 我的机器上8 线程(与前面的网络层共享= CPU数量), 默认有256个unordered_map, 每个线程管理8个unordered_map, 之所以分开为256个unordered_map,
主要是为了解决unordered_map的自动扩展时, 会有大量的拷贝, 分开256个以后, 一次扩展拷贝数据的数量就少, 性能抖动小,
其次, 由于每个map都是单线程驱动的, 因此, map的读写不需要加锁
数据层对网络层提供多个io_service 命令和多个 线程间队列,作为接口,  一起驱动数据查询, 数据更新, 数据增加, 数据删除, 操作全部是在unordered_map.
因此, 数据层是高并发的, 并发量=CPU数量  数据层其实是数据索引层,  查询Key得到的只是Global_offset, 还没有得到数据, 后面要进入File_mapping层去存取数据,
数据层的特点是全并发
数据层unordered_map 的的第2个参数是Global Offset, 64bit, 通过计算变换, 得到文件名, 文件offset, 就可以进入file_mapping_read层进行查询. 读查询是直接采用数据层的线程直接读的, 读是全并发的,

File_mapping层主要实现文件数据的缓冲, 分解为read和write这两种对象, 实行读写分离, 读并发无限制, 写不能并发, 其中file_mapping_read是一组多个对象, 每个对象都代表了一个文件, 每个文件都可以同时被所有线程同时并发读,  
file_mapping_write是单对象, 由单线程驱动, 与其他线程之间, 通过Wait_free_mpsc_queue接收写指令, 然后写入后, 其他线程再通过反向的io_service.post调用获得驱动,
File_mapping_write默认是每秒刷新到磁盘一次, 可调可取消, 也可设置为每N个write刷新到磁盘.

以上就是本次设计的主要思路, 都是基于高并发的设计.
个人觉得, 代码中几个设计都是比较好的.
一个是file_mapping层读写分离(写单线程驱动)的设计思路, 堪称经典, 对比mongodb的一把大锁走天下的设计, 并发要好很多.
一个是数据层分开为多个map的设计, 每个map单线程的驱动方式, 对比redis的单线程, 和map扩展, 并发好很多.
一个是file_mapping层的顺序写数据结构设计, 对比monggodb的到处随机写, 更适合SSD.
一个是实现了任意对象的Wait_free_queue的设计代码,可作为Boost库的补充.

HughNian

mark一下lollol

wlmqgzm

// TODO: field id下推到底的优化: 考虑字段 field_id目前是4字节, 每一行数据都包含, 如果一行数据有32个字段, 那么就是128字节, 这个浪费量也很惊人.
// 每个块如果包含250行, 那么就是32K字节浪费, 因此, 考虑修改底层行编码的格式:
//  就是每1----250行一个块, 每个块的开始要包含数据字段的定义, 主要是Not NULLfield, 这样每行数据将变为2种数据的组合, 一个部分是非空字段的定义, 一个空字段的定义.
//  非空字段在块开头定义了每个字段的id(4字节), 类型1字节, 默认值长度 , 默认值, 字段编号num1字节,   
//  在行中:字段编号num1字节,字段长度为压缩整数1-5字节, 字段内容
//  进一步利用默认值进行压缩: 当压缩整数第1字节表示长度的长度=255时,表示=默认值,无需字段内容,可再压缩. 即  =默认值的字段,  被压缩到2个字节, 无字段内容
//  对于NULL field, 那么还是要下推到底的, 因为这些field是可以不存在的, 对于空字段,实际占用空间=0, 其他情况, 在行中:字段id 4字节,类型1字节,长度的长度1字节, 长度0-4字节,字段内容
//  考虑IO是主要瓶颈, 宁可利用CPU的资源来减少, 因此, 这部分的设计还在继续修改, 以便提供更高的效率.

Not NULL Field高效率存储, 不需要在每行都定义, 等于默认值的field被压缩到2个字节,    NULL Field有数据的情况下,在行中定义, 字段Filed_id下推到底, 无数据的话不占空间.
程序中的块定义越来越复杂了, 但是主要目的是为了尽可能的实现更先进的结构
总之,上面的改进就是结合了innodb和NOSQL的数据结构的优点.