Thread local storage(tls) is a feature provided by most modern operating
systems(OS) that allow multiple threads within a process to have its own “global”
data, but the scope of the “global” data is restricted within a thread
itself, i.e. tls variables are thread wide global variables.

TLS can be useful if we want to store global data which are grouped by
threads, each thread only accesses its own piece of data, and have no loss of
concurrency. Without tls, we would have to store such data in a global data
structure (process wide) and use locks to sychronize access to it.

2. Two Ways to Support TLS

The support to tls feature includes two ways: compiler keyword support and
thread library API support.

2.1 Compiler keyword support:

If we declare an integer variable P a tls variable on Windows, we can do it like
this:

__declspec(thread) int P;

Or if we want to define a static data member S of class C as a tls variable so
that each thread access its own copy of S when it accesses C::S, we will
declare it like this:

class C {
public:
static __declspec(thread) int S;
// The rest follow…
};

template <typename T>
class CT {
public:
static __declspec(thread) T* ST;
// The rest follow…
};

And define it like this:

__declspec(thread) int C::S = 0;

template <typename T>
__declspec(thread) T* CT::ST = NULL;

2.2 Portability

Unfortunately, different compilers and OS have different keywords, for MSVC
it is __declspec(thread); for gcc and icpc (intel c++ compiler), it’s __thread;
and some other compilers like those on HPUX use __declspec(__thread).

So it takes some effort to
write portable tls code that can run on multiple platforms using multiple
compilers — we need to provide the correct tls keyword for the target
platform and compiler.

A more terrible issue that makes writing such portable code harder is that
in the above CT<T>::ST example, some
compilers like icpc require the tls keyword only appear in the declaration,
if CT<T>::ST’s definition also has the tls keyword, icpc can’t build the code.
And having only a tls declaration is enough to make CT<T>::ST a tls variable.
But icpc require tls keyword appear in C::S’s definition, strange enough.

However, some other compilers like the older ( < 4.0) versions of gcc require
the tls keyword
appear in both the declaration and definition, otherwise although the build
succeeds, the variable CT<T>::ST or C::S is not handled as a tls variable,
thus multiple thread access will have races and result in undefined behaviors;

Newer versions of gcc will take CT<T>::ST and C::S as a tls variable once it’s
declared as tls, whether or not the definition has tls keywords. This is also
true for icpc if the class is not templated. Since icpc is trying to mimic gcc
as much as possible, I think it’s icpc’s bug that it can’t accept a tls
keyword in CT<T>::ST’s definition.

A portable implementation in dbstl implementation is to detect appropriate tls declaration and
definition keywords when configuring, using the m4 scripts. We will iterate
through the (“__declspec(thread)”, “__thread”, “__declspec(__thread)”, “”)
array for a combination that builds the class C and CT, and exclude the
(“”, “”) combination of course. Also note that the “” must be placed at last
otherwise if the compiler is a older version of gcc, the tls keyword in
definition will be blank, and we will get a non-tls variable instead; when we
apply this technique, we will find icpc end up with no appropriate tls
keyword combinations.

2.3 Thread API Support

Another way to use tls is through thread API. For example, in pthread, we
first create a tls key, then use this key to get/set the thread-specific copy
of the tls variable assocaited with the key for each thread.
We create the tls key via the pthread_key_create call.
And in order to avoid multiple initializations to the same key, we use
pthread_once to make sure the pthread_key_create is called only once.

When we have the tls key, we can call pthread_setspecific to write to this
thread’s tls variable, or call pthread_getspecific to read this
thread’s tls variable.

Some platforms only has the thread API support, like Mac OSX; For others if they
don’t have pthread API, or other thread library that support tls, they will
need to have a tls keyword to support this feature.

2.4 TLS in Dbstl Implementation

In dbstl, we always prepared both choices, and make the choice when
configuring — if the platform and compiler has tls keyword support, we use it;
otherwise we use pthread tls API; If neither pthread API nor tls keywords
are available, this platform won’t be able to use dbstl in multiple threads.

See the $(DB)/stl/dbstl_resource_manager.h/cpp for example code.

大家好，

像Facebook, linkedin, Google search, twitter等一些大规模分布式的应用上，往往需要部署成千上万的服务器来做集群，要求很高的响应时间和吞吐量，极佳的可扩展性。事实上，在这种分布式场合，传统的关系型数据库就不再合适了。而往往需要的只是一个按主键来访问的key/value 的数据库引擎，并且要求该引擎可以运行在普通硬件上，多平台上。

根据国外的反馈，Berkeley DB在相应场合的部署正越来越热，比如Amazon，Google，EMC等关键性服务上。又比如一些知名的，运行在分布式应用的开源产品上，如MemcacheDB, Project Voldemort, ThruDB, Amazon Dynamo等。

如果，国内有从事相关大规模云计算应用的朋友，欢迎留言。

另外，如果有兴趣从事该方向的朋友，也可以读读Amazon Dynamo的论文： http://www.allthingsdistributed.com/2007/10/amazons_dynamo.html。有问题，欢迎提问。

Berkeley DB 中国开发团队

If your code builds well using gcc4.3 and below, it may not build with gcc4.4, which was released in April 2009.

Following are some of the changes that violates c/c++ standard:

1. gcc4.4 does not by default #include stdio.h, or stdlib.h, no header files are by default included, all header files of standard c/c++ libraries need to be explicitly included.

2. More warning checks, e.g. if/else partitions.

This code snippet:

if (a)

if (b)

do something here;

else

do something else here;

The above will cause warnings, instead you need this:

if (a) {

if (b)

do something here;

else

do something else here;

}

3. Stricter enum checks.

Basically we can not rely on the rules to evaluate enum members to integers which were true before; we can not use the integer values of enum members, we can only use the literal enum members. For example, we can not use them to compare with integral values, or members of another enum type. We can only compare with other enum members of the same type for equality.

4. Use standard ansi c++ include

For C library header files, #include <cstdio>; rather than #include <stdio.h>;

And also need to “use namespace std;” because all C functions are put into the std namespace.

This item is not required now, but since it is standard c++ we should follow it and abandon the old fashion in case some day later our code fails to build with latest c++ compiler.

Following are some corner cases of C++ template features. A lot of the text is simply extracted from “C++ Templates: The Complete Guide”, with some of my personal understanding. These features are trivial and easily neglected, but you should have some impression to them in case you run into troubles caused by the neglect.

I made my notes in English, and I don’t bother to translate them into Chinese, forgive my laziness.

0. use “typename” to extract type defined within a type parameter, like this: typename T::iterator itr; otherwise the ‘itr’ is treated as a data member of T.

1. zero initialization
When using a var x of type T, we MUST initialize it like this: T x = T(); so that when T is a primitive type, x can also be initialized with 0, or NULL (when T is a pointer type). Of course we must make sure
when T is a class type, it has a default constructor. Simply using T x; can’t initialize x when T is a primitive type.

2. .template

The .template Construct
A very similar problem was discovered after the introduction of typename. Consider the following example using the standard bitset type:

template<int N>
void printBitset (std::bitset<N> const& bs)
{
std::cout << bs.template to_string<char,char_traits<char>,
allocator<char> >();
}
The strange construct in this example is .template. Without that extra use of template, the compiler does not know that the less-than token (<) that follows is not really “less than” but the beginning of a template argument list. Note that this is a problem only if the construct before the period depends on a template parameter. In our example, the parameter bs depends on the template parameter N.

3. char star string type at reference type parameter
Suppose we have a string str: char str[32]; The type of ’str’ symbol is “a char string” and “of 32 chars long”. similarly the literal “abc” ’s type is: ” a char string” and “of 3 chars long”,
that is, the “type” information consists of both “base type”, which is “char”, and “length”, which is 32 here. So
such a string is of different type to a char* pointer, such as char*p; , a type conversion is done if passing a string literal as argument to a function with char* formal parameter.

template <typename T>
inline T const& max (T const& a, T const& b)
{
return a < b ? b : a;
}

So when we use max(“abc”, “def”) to call above function, it is OK. but if we use max(“abc”, “defg”) to call it, it is wrong, because “abc” and “defg” are of different types — the length is different. And automatical type conversion is not done for reference types here.

This means that the above array ’str’, and string literals like “abc”, is not of the same type as “char *pstr;”, as most people may believe. Actually it takes a conversion to convert ’str’ array or the string literals to a ‘char*’ type. However, during template argument deduction array-to-pointer conversion (often called decay) occurs only if the parameter does not have a reference type. Thus we have the above issue. And if we don’t use reference in above code, like this:
template <typename T>
inline T max (T a, T b)
{
return a < b ? b : a;
}

Both max(“abc”, “def”) and max(“abc”, “defg”) can build OK, since a automatic conversion from string literal to char* is done, so finally we have the same type ‘char*’ as T.

4. template template types
After reading the whole lot of text in the book, I realized that this is really a very particular feature, too complicated and restricted to use widely.
Though, since it is a very recently added new C++ template feature, it can be used in your configure script to test whether your compiler conforms to
C++ language standard. The piece of code in the book can directly be used in your m4 file for configure to use.

C++ template is really a powerful gun in the entire C++ artillery. It is an important part of the defining components that make C++ so powerful, yet so difficult to learn. There are many ways you can make mistakes when using C++, or using C++ templates, just like using any other powerful man-made systems. But if you make everything right, you can gain incredible power, flexibility, efficiency, performance, extendability and so on – anything you dream of in the software engineering world. So it is definitely worthwhile to make the effort to learn C++ well.

In this article I’d like to talk about how to implement the superset of interface mechanism using templates in C++ by using C++ templates, you can do a lot better than ordinary interface mechanism.

In C++ we don’t have an “interface” language component like Java, so we use pure abstract class to simulate it, and which is enough for a Java style ordinary interface. But if we use templates, we can gain a superset of interface functionalities, then you will find how limited and naive the Java interface is.

Ordinary interfaces restrict any type which implements the methods required by an interface A to derive from the interface A, otherwise it is not suitable for the tasks declared to require A even if it has all the required methods, i.e. ability. The interface A is a tag imposed to the two parties of the contract the provider P has to have this tag A — to be a descendant of A — in order to work with the consumer T which requires a provider with the abilities defined in A, otherwise even if P has the ability required, it is not suitable and can’t be used. This is caused by the limitation that T has to express the requirement of abilities in the form of “You have to be a descendant of A”.

In Chinese, there is a saying: “王侯将相，宁有种乎!”, meaning “A king is not a king because he is born by a King! (Anyone who can do the king’s job can be a king!)” . As said above, P has to be a descendant of A in order to work with T, which is just a vivid example of this unfareness. This unfairness makes it very restricted and limited for software developers in many ways, let’s see some of them:

1. When you can’t derive P from the interface A
When P is a written class built into a shared module (.dll, .so files), or for other reasons you will probably meet in any real world project, you just can’t derive P from A, and you can’t derive a new class from P in this case either, thus you can’t use an instance of P to work with T.

But if you are using templates, as long as you define the set of methods required by T in P, and T is also using templates to express the requirement, then you can always use an instance of P to work with an instance of T.

The way T express the requirement “You must have the set of methods defined in A” is: don’t say anything but simply assume the requirement is satisfied. And if not, there will be compiling errors.

Because of this flexibility, you can define methods required by several classes in P, but not adding any interface tags to P, and P will be suitable for all occasions where any subset of P’s set of methods are required.

2. Primitive types — technically unable to implement any interface
Primitive types like int, double, char*, etc, can not derive from any interface or class, what if you want an interface to mediate the P and T? This is something I met several months ago.

My use case was: I wanted to do marshal and un-marshal of various types in order to store/retrieve them into/from a database in a consistent way. For each type T, I need a function to return an object’s size in bytes, a function to marshal an object of T (putting its bytes to store into a chunk of memory), and a function to unmarshal (by filling an object’s fields with a chunk of memory previously marshaled). The three types of functions all have default behaviors (sizeof operator for size measuring, memcpy for marshal and unmarshal). When no functions are provided, we can fall back to use default behaviors.

The types include primitive types as well as class/struct types, so obviously I can’t use ordinary interface. But I can do so using templates. Details as follows:

1. Define a TypeTraits<T> class template, make it a singleton.

2. In TypeTraits<T>, the three types of functions can be defined as three types of function pointer:

typedef size_t (*size_func_t)(const T&)
typedef void (*marshal_func_t)(void *dest, const T& src);
typedef void (*unmarshal_func_t)(T&dest, const void*src);

3. Define data members of the three types as well as the get/set functions for the data members.

This way users can assign different functions for different types, or don’t assign at all but use default behavior if appropriate.

In places using this “INTERFACE”, we first check if the needed function is registered, if not, use default behavior, otherwise use the registered function.

This way, all types are well supported.

There are a lot of things we can do with templates very gracefully and easily, I will cover them in later articles.

用这么一台老古董，无非是玩玩DOS游戏，看看电子小说。老DOS用户都熟悉知名程序员云风写的一个牛掰的电子小说阅读软件C-View，支持N多的功能。唯一的遗憾就是全屏分行，按行滚动。阅读时眼睛或脖子需要不停地左右往复，实是累坏吾等老汉。

总而言之，看小说还是要那种仿书页样式的，这样才有看书的感觉。看的时候左一页，右一页，看完左页看右页，看完前页看后页…  可惜寻觅半天，在DOS下还是找不到合适的阅读器。那就只好自己写一个吧，所幸不难。猛蹲一阵图书馆和宿舍，炮制出来一个能工作的程序，从此终于可以用它来安详地看书了。

在华军上的简介(http://www.newhua.com/soft/22394.htm)：

唯一的DOS仿真书页样式阅读器,模拟左右翻页的书页样式。自带中文GB字库，无需汉字系统支持，无需EMS或XMS。硬件级的色彩调整,可由用户设定2 万多种颜色.可设定背景、 字体、页码等页面所有元素颜色。并提供四种调色方案的设定、保存和快速切换。文件选择采用磁盘目录列表选择，并配有预览功能。能打开任意大小的文本文件。

DOS仿真阅读器在电脑里保存了两年，直至05年本科毕业。至于陪伴了我三年的486笔记本，在毕业前夕转让给了师弟，也许现在这个老机器早已停止运转了吧。用它打穿的DOS游戏早已不计其数：大航海时代II、英杰传、炎龙骑士团、波斯王子、三国志IV、轩辕剑II……嗯，又想起了扛着一盒软盘去学校机房拷游戏的时光。

千里之行，始于足下。越是历久弥香的产品，越是要求严格，也就意味着每一行代码都很讲究。要做出世界一流的软件来，除了要遵循软件项目管理的种种规范（需求、设计、风险、测试等等），对于开发者的编码要求和规范也不少。

我想，在此谈谈我的一点浅见。对于一个合格的开发者而言，其编写每一行代码的时候，大致首先要考虑的地方有：
- 我遵循相关的代码规范了没有？
- 注释写了没有？注释写的简洁明了吗？
- 针对各种异常情况加以判断和处理了吗？
- 安全退出了吗？释放内存没？有没有内存泄漏？

下面分别简单说明一下。
- 我遵循相关的代码规范了没有？
1. 比如，Sun的Java代码规范要求缩进，貌似很多人注意到了。但是按80个字符折行，你注意到了吗？在咱们Berkeley DB Java版做开发甚至还要求每个函数体不超过一屏幕高。有人不理解，为什么？应为，只有这样，在各种屏幕/环境下看到的你的代码样式都是一致的。从而，方便别人审阅你的代码，也方便了自己。
2. 对变量，函数，类等命名时要遵循代码规范。举个反面例子，假设一个项目组成员10人，有人喜欢用getObject()来命名，有人喜欢readObject()，有人倾向retrieveObj()，有人用getInstance()… 其结局不言而喻。

- 注释写了没有？注释写的简洁明了吗？
举个例子，你要在程序中做排序。你决定实现最简单的冒泡排序。学过计算机的都知道，冒泡排序代价很昂贵，但是若排序的个体数目不大的时候（比如n<10）却用起来不错。所以当你写代码的时候，就应该大致这样写注释：
/**
* We need to sort the elements, since that will allow us to easily index
* into the array. Since the number of elements is expected to be small, it
* is okay to use bubble sort. If the number of elements to be sorted is
* significant, then it would be appropriate to use a more efficient
* sorting algorithm.
*/

- 针对各种异常情况加以判断和处理了吗？
假设有个功能模块，接受从输入流传过来的数据。在理想情况下，预期输入的可能是用户姓名，格式化的：（First, Middle, Last）。那么，我想程序开发者在实现这个功能的时候，应该考虑到，传过来的可能是西文字符集，中文字符集。同样，也有可能是不规则的姓名（First, Last, Middle），空，数字，超出越界（假设每个名字不超过128个字符）。当然，也有可能是内存地址（引用），二进制照片，不可见字符等等。该功能要robust，种种情况都应该要考虑到。

当然，这只是一个输入检查的情况。在程序运行时刻，还有可能遇到内存不够，并发读写等等情况。

- 安全退出了吗？释放内存没？有没有内存泄漏？
安全退出了吗？是的，返回正确退出的信号量了。释放变量了吗？貌似也做了。是吗？接受Ctrl+c吗，结果是什么？

有时候，程序运行几天甚至更久，显示内存不够了，程序自动停止下来。是内存泄漏吗，怎么办？

Java 开发者发现，即便有Java提供的内存回收机制，有很多程序也有内存泄漏，最后导致生产环境应用down掉。

我个人认为：遵循一些编码规范，多测试，多积累经验，不断优化你的code是个不错的建议。

先写到这里, 欢迎有体会或者有兴趣的朋友和我交流哦…

* Stanford大学教授Hector Garcia-Molina同志的书，比如prentice Hall出版的“Database System Implementation”。（Hector Garcia-Molina同志也是Oracle公司顾问团成员之一。)

* 数据库权威Jim Grey的书，比如“Transaction Processing: Concepts and Techniques”。

学习初期，可以考虑研究如下方向：

a) b-tree indexing
b) hash indexing (Linear hashing in particular)
c) logging and recovery
d) buffer management
e) concurrency control and locking

Brett Zamir在创建XqUSEme初期与Berkeley DB开发工程师的讨论在： http://forums.oracle.com/forums/thread.jspa?messageID=2239564。

有心的朋友，不知道有考虑过智能手机+浏览器+BDBXML的组合吗？欢迎和我讨论。

echo 2> tmp.txt

stderr没有任何输出，自然产生一个空白文本文件。整个世界清静了…