char *key_buf, *data_buf;
void *p;
int j;

/* Initialize structs and arrays */
memset(raw_key, 0, KEY_SIZE);
memset(raw_data, 0, DATA_SIZE);
memset(&key, 0, sizeof(DBT));
memset(&data, 0, sizeof(DBT));
tid = NULL;

/* Initialize bulk insertion buffers */
key_buf = malloc(KEY_SIZE * bulk_size * 2);
data_buf = malloc(DATA_SIZE * bulk_size * 2);
memset(key_buf, 0, KEY_SIZE * bulk_size * 2);
memset(data_buf, 0, DATA_SIZE * bulk_size * 2);

/*
* 初始化Bulk buffer.使用批量操作(bulk operations) 也就是
* 批量插入/删除/更新/读取的时候，必须使用用户提供的内存。
* 所以需要设置DBT对象的flags为DB_DBT_USERMEM，并且设置ulen成员而不是size成员。
*/
key.data = key_buf;
key.ulen = KEY_SIZE * bulk_size * 2;
key.flags = DB_DBT_USERMEM;
data.data = data_buf;
data.ulen = DATA_SIZE * bulk_size * 2;
data.flags = DB_DBT_USERMEM;

op_flag = DB_MULTIPLE;/* 这个flag给put/get/del 表示执行批量插入/更新/读取/删除。 */

/*
* 填充一个bulk buffer DBT 对象. 先调用DB_MULTIPLE_WRITE_INIT初始化该
* DBT。必须传入一个工作指针p和data buffer DBT 对象。
*/
DB_MULTIPLE_WRITE_INIT(p, &data);
for (i = 0; i < bulk_size; i++) {
/*
* 调用DB_MULTIPLE_WRITE_NEXT这个宏来向bulk buffer当中插入数据。
* 需要确保bulk buffer足够大，否则会出现内存访问越界错误。
*
* 各参数说明：
* p: 是这个宏内部使用的工作变量，由DB_MULTIPLE_WRITE_INIT初始化，并且必须在此处一直使用。
* data: 是data buffer DBT对象。
* raw_data: 是一个数据项所在的内存地址。你需要把你要装入的数据项传入这个参数。每个数据项
* 可以含有任意长度的字节，长度限制是一个DBT的总长度限制，也就是2的32次方。
* DATA_SIZE: 是本次宏调用的数据项长度。本例当中所有数据项长度相同，只是特例。完全可以
* 使用变长的数据项。
*
* 循环结束后填充完成，这个data buffer当中有bulk_size个data，
*/
DB_MULTIPLE_WRITE_NEXT(p, &data, raw_data, DATA_SIZE);
}

/*
* 批量插入insert_count条key/data pairs, 每一批插入bulk_size条key/data pairs.
* 本例当中我们只准备了一批数据，所以最终插入的数据是重复的，不过这不影响示例本身。
*/
for (i = 0; i < insert_count / bulk_size; ) {
/*
* 填充key buffer。填好后，这个key buffer当中有bulk_size个key，
* 并且第i个key与data buffer 当中的第i个data做为一对key/data pair
* 被插入数据库当中(i = 0, 1, 2, … bulk_size).
*/
DB_MULTIPLE_WRITE_INIT(p, &key);
for (j = i * bulk_size; j < (i + 1) * bulk_size; j++) {
raw_key[0] = insert_load[j];
/* 在循环当中使用DB_MULTIPLE_WRITE_NEXT依次插入每条data到data buffer当中。
* 循环结束后填充完成。*/
DB_MULTIPLE_WRITE_NEXT(p, &key, raw_key, KEY_SIZE);
}

/* 启动事务准备批量插入。 */
if ((ret = envp->txn_begin(envp, NULL, &tid, 0)) != 0) {
envp->err(envp, ret, “[insert] DB_ENV->txn_begin”);
exit(EXIT_FAILURE);
}

/*
* 执行批量插入。key和data DBT 对象分别是key buffer和data buffer,
* 其中必然含有相同书目的key和data items,key buffer当中的第i个
* key item与data buffer当中的第i个data item 作为一个Key/data pair
* 被插入数据库中。(i = 0, 1, 2, … bulk_size).
*/
switch(ret = dbp->put(dbp, tid, &key, &data, op_flag)) {
case 0: /* 批量插入操作成功，提交事务。*/
if ((ret = tid->commit(tid, 0)) != 0) {
envp->err(envp, ret, “[insert] DB_TXN->commit”);
exit(EXIT_FAILURE);
}
break;
case DB_LOCK_DEADLOCK:
/* 如果数据库操作发生死锁，那么必须abort事务。然后，可以选择重新执行该操作。*/
if ((ret = tid->abort(tid)) != 0) {
envp->err(envp, ret, “[insert] DB_TXN->abort”);
exit(EXIT_FAILURE);
}
continue;
default:
envp->err(envp, ret, “[insert] DB->put ([%d]%d)”, i, insert_load[i]);
exit(EXIT_FAILURE);
}

i++;
}

(void)free(key_buf);
(void)free(data_buf);

return (NULL);
}

/* 批量插入示例函数。*/
void *
run_bulk_delete()
{
int raw_key[NUM_KEY_INT];
DBT key;
DB_ENV *envp;
DB *dbp;
DB_TXN *tid;
int *delete_load;
int delete_count, id, i, ret, op_flag;
double tmp;

char *key_buf;
void *p;
int j;

/* Initialize structs and arrays */
memset(raw_key, 0, KEY_SIZE);
memset(&key, 0, sizeof(DBT));
tid = NULL;

/*
* 初始化批量删除使用的key buffer。由于批量删除不需要data，
* 所以只需要初始化和填充key buffer。我们同样需要使用自己分配的内存。
*/
key_buf = malloc(KEY_SIZE * bulk_size * 2);
memset(key_buf, 0, KEY_SIZE * bulk_size * 2);

/* 初始化key buffer DBT 对象，设置正确的flags和ulen成员。 */
key.data = key_buf;
key.ulen = KEY_SIZE * bulk_size * 2;
key.flags = DB_DBT_USERMEM;
op_flag = DB_MULTIPLE; /* 批量删除同样需要这个flag。*/

/*
* 批量删除所有的数据。每一批删除由key buffer DBT 当中的key
* 指定的bulk_size条key/data pair. 这两个宏的详细用法见上文。
*/
for (i = 0; i < delete_count / bulk_size; ) {
/* 为批量删除初始化并填充一个key buffer DBT 对象。 */
DB_MULTIPLE_WRITE_INIT(p, &key);
for (j = i * bulk_size; j < (i + 1) * bulk_size; j++) {
raw_key[0] = delete_load[j];
DB_MULTIPLE_WRITE_NEXT(p, &key, raw_key, KEY_SIZE);
}
/* 启动事务。*/
if ((ret = envp->txn_begin(envp, NULL, &tid, 0)) != 0) {
envp->err(envp, ret, “[delete] DB_ENV->txn_begin”);
exit(EXIT_FAILURE);
}

/*
* 执行批量删除。key buffer DBT
* 当中的bulk_size条key指定的key/data pairs会被从数据库当中删除。
*/
switch(ret = dbp->del(dbp, tid, &key, op_flag)) {
case 0: /* 批量删除操作成功，提交事务。*/
if ((ret = tid->commit(tid, 0)) != 0) {
envp->err(envp, ret, “[delete] DB_TXN->commit”);
exit(EXIT_FAILURE);
}
break;
case DB_LOCK_DEADLOCK:
/* 如果数据库操作发生死锁，那么必须abort事务。然后，可以选择重新执行该操作。*/
if ((ret = tid->abort(tid)) != 0) {
envp->err(envp, ret, “[delete] DB_TXN->abort”);
exit(EXIT_FAILURE);
}
continue;
default:
envp->err(envp, ret, “[delete] DB->del ([%d]%d)”, i, delete_load[i]);
exit(EXIT_FAILURE);
}
i++;
}

(void)free(key_buf);

return (NULL);
}

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.

 memset(&setup_info, 0, sizeof(SETUP_DATA));
 setup_info.progname = progname;
 memset(&my_app_data, 0, sizeof(APP_DATA));
 dbenv = NULL;
 ret = 0;
 /*
  * 默认使用选举的方法选出master。替代方案就是指定某一个site是master，
  * 其他site是replica。
  */
 start_policy = DB_REP_ELECTION;

 /* 创建一个拥有replication功能的数据库环境，但还不打开。 */
 if ((ret = create_env(progname, &dbenv)) != 0)
  goto err;
 dbenv->app_private = &my_app_data;

 /*
  * 配置replication消息处理回调函数。
  * 有任何replication消息，Berkeley DB都会调用该函数来处理。
  */
 (void)dbenv->set_event_notify(dbenv, event_callback);

 /* Parse command line and perform common replication setup. */
 if ((ret = common_rep_setup(dbenv, argc, argv, &setup_info)) != 0)
  goto err;

 /*
  * Perform repmgr-specific setup based on command line options.
  * 如果显式指定了master，那么就使用DB_REP_MASTER把本site设置为master，
  * 并用DB_REP_CLIENT把其他site设置为replica。
  */
 if (setup_info.role == MASTER)
  start_policy = DB_REP_MASTER;
 else if (setup_info.role == CLIENT)
  start_policy = DB_REP_CLIENT;
 /*
  * 设置本地site信息，也就是IP地址和端口信息。因为site是一个
  * （数据库环境，IP地址，port）的三元组，而数据库环境我们已经创建好
  * 了。
  */
 if ((ret = dbenv->repmgr_set_local_site(dbenv, setup_info.self.host,
     setup_info.self.port, 0)) != 0) {
  fprintf(stderr, “Could not set listen address (%d).\n”, ret);
  goto err;
 }
 site_list = setup_info.site_list;
 /*
  * 添加其他site的信息到本site。如果显式指定master，那么一个replica
  * 一定要知道master的信息；如果选举，那么每一个site要知道其他所有
  * site的信息。
  *
  * 两个site可以成为peer关系，通过在下面的函数中设置
  * DB_REPMGR_PEER来指定。一个replica可以被它的peer更新到最新，这样
  * 就为master去掉了更新过时的replica的负担。
  */
 for (i = 0; i < setup_info.remotesites; i++) {
  if ((ret = dbenv->repmgr_add_remote_site(dbenv,
      site_list[i].host, site_list[i].port, NULL,
      site_list[i].peer ? DB_REPMGR_PEER : 0)) != 0) {
   dbenv->err(dbenv, ret,
       “Could not add site %s:%d”, site_list[i].host,
       (int)site_list[i].port);
   goto err;
  }
 }

 /*
  * Configure heartbeat timeouts so that repmgr monitors the
  * health of the TCP connection.  Master sites broadcast a heartbeat
  * at the frequency specified by the DB_REP_HEARTBEAT_SEND timeout.
  * Client sites wait for message activity the length of the
  * DB_REP_HEARTBEAT_MONITOR timeout before concluding that the
  * connection to the master is lost.  The DB_REP_HEARTBEAT_MONITOR
  * timeout should be longer than the DB_REP_HEARTBEAT_SEND timeout.
  */
 if ((ret = dbenv->rep_set_timeout(dbenv, DB_REP_HEARTBEAT_SEND,
     5000000)) != 0)
  dbenv->err(dbenv, ret,
      “Could not set heartbeat send timeout.\n”);
 if ((ret = dbenv->rep_set_timeout(dbenv, DB_REP_HEARTBEAT_MONITOR,
     10000000)) != 0)
  dbenv->err(dbenv, ret,
      “Could not set heartbeat monitor timeout.\n”);

 /*
  * The following repmgr features may also be useful to your
  * application.  See Berkeley DB documentation for more details.
  *  – Two-site strict majority rule – In a two-site replication
  *    group, require both sites to be available to elect a new
  *    master.
  *  – Timeouts – Customize the amount of time repmgr waits
  *    for such things as waiting for acknowledgements or attempting
  *    to reconnect to other sites.
  *  – Site list – return a list of sites currently known to repmgr.
  */
 /* 打开数据库环境。*/
 if ((ret = env_init(dbenv, setup_info.home)) != 0)
  goto err;

 /* Start checkpoint and log archive threads. */
 sup_args.dbenv = dbenv;
 sup_args.shared = &my_app_data.shared_data;
 if ((ret = start_support_threads(dbenv, &sup_args, &ckp_thr,
     &lga_thr)) != 0)
  goto err;

 if ((ret = dbenv->repmgr_start(dbenv, 3, start_policy)) != 0)
  goto err;

 if ((ret = doloop(dbenv, &my_app_data.shared_data)) != 0) {
  dbenv->err(dbenv, ret, “Client failed”);
  goto err;
 }

 /* Finish checkpoint and log archive threads. */
 if ((ret = finish_support_threads(&ckp_thr, &lga_thr)) != 0)
  goto err;

 /*
  * We have used the DB_TXN_NOSYNC environment flag for improved
  * performance without the usual sacrifice of transactional durability,
  * as discussed in the “Transactional guarantees” page of the Reference
  * Guide: if one replication site crashes, we can expect the data to
  * exist at another site.  However, in case we shut down all sites
  * gracefully, we push out the end of the log here so that the most
  * recent transactions don’t mysteriously disappear.
  */
 if ((ret = dbenv->log_flush(dbenv, NULL)) != 0) {
  dbenv->err(dbenv, ret, “log_flush”);
  goto err;
 }

err:
 if (dbenv != NULL &&
     (t_ret = dbenv->close(dbenv, 0)) != 0) {
  fprintf(stderr, “failure closing env: %s (%d)\n”,
      db_strerror(t_ret), t_ret);
  if (ret == 0)
   ret = t_ret;
 }

 return (ret);
}

/*
 * 事件通知函数。当使用replication manager的时候，该事件已经被
 * replication manager 适当地处理好了，所以在这个回调函数当中，
 * 我们只需要简单地更新状态或者打印消息即可。
 */
static void
event_callback(dbenv, which, info)
 DB_ENV *dbenv;
 u_int32_t which;
 void *info;
{
 APP_DATA *app = dbenv->app_private;
 SHARED_DATA *shared = &app->shared_data;

 info = NULL;    /* Currently unused. */

 switch (which) {
 case DB_EVENT_REP_CLIENT:
  shared->is_master = 0;
  shared->in_client_sync = 1;
  break;

 case DB_EVENT_REP_MASTER:
  shared->is_master = 1;
  shared->in_client_sync = 0;
  break;

 case DB_EVENT_REP_NEWMASTER:
  shared->in_client_sync = 1;
  break;

 case DB_EVENT_REP_PERM_FAILED:
  /*
   * Did not get enough acks to guarantee transaction
   * durability based on the configured ack policy.  This
   * transaction will be flushed to the master site’s
   * local disk storage for durability.
   */
  printf(
    “Insufficient acknowledgements to guarantee transaction durability.\n”);
  break;

 case DB_EVENT_REP_STARTUPDONE:
  shared->in_client_sync = 0;
  break;

 default:
  dbenv->errx(dbenv, “ignoring event %d”, which);
 }
}

got_self = is_repmgr = maxsites = ret = site.peer = 0;

/*
* 站点的优先级。在选举的时候，如果多个站点具有最新的日志，那么
* 优先级最高的站点成为master。所以，应该把后备做master的站点
* 设置更高的优先级。
*/
priority = 100;

/*
* 持久消息(permanent message, i.e. commit/abort/checkpoint日志)
* 确认策略。repmgr要求replica根据持久消息做相同的动作
* (commit/abort/checkpoint)，然后对持久消息进行确认。repmgr等待一定
* 数目的replica确认，这个数目字这里设置。
*/
ack_policy = DB_REPMGR_ACKS_QUORUM;
setup_info->role = UNKNOWN;
if (strncmp(setup_info->progname, “ex_rep_mgr”, 10) == 0)
is_repmgr = 1;

/*
* Replication setup calls that are only needed if a command
* line option is specified are made within this while/switch
* statement.  Replication setup calls that should be made
* whether or not a command line option is specified are after
* this while/switch statement.
*/
while ((ch = getopt(argc, argv, “a:bCh:l:Mn:p:R:r:v”)) != EOF) {
switch (ch) {
case ‘a’:
if (!is_repmgr)
usage(is_repmgr, setup_info->progname);
if (strncmp(optarg, “all”, 3) == 0)
ack_policy = DB_REPMGR_ACKS_ALL;
/* repmgr等待所有站点的持久消息确认。*/
else if (strncmp(optarg, “quorum”, 6) != 0)
usage(is_repmgr, setup_info->progname);
break;
case ‘b’:
/*
* 批量传输设置。在bulk buffer满了或者有了持久消息
* (permanent message)的时候才传输所有的消息。
* Configure bulk transfer to send groups of records
* to clients in a single network transfer.  This is
* useful for master sites and clients participating
* in client-to-client synchronization.
*/
if ((ret = dbenv->rep_set_config(dbenv,
DB_REP_CONF_BULK, 1)) != 0) {
dbenv->err(dbenv, ret,
“Could not configure bulk transfer.\n”);
goto err;
}
break;
case ‘C’:
setup_info->role = CLIENT;
break;
case ‘h’:
setup_info->home = optarg;
break;
case ‘l’:
setup_info->self.host = strtok(optarg, “:”);
if ((portstr = strtok(NULL, “:”)) == NULL) {
fprintf(stderr, “Bad host specification.\n”);
goto err;
}
setup_info->self.port = (unsigned short)atoi(portstr);
setup_info->self.peer = 0;
got_self = 1;
break;
case ‘M’:
setup_info->role = MASTER;
break;
case ‘n’:
setup_info->nsites = atoi(optarg);
/*
* For repmgr, set the total number of sites in the
* replication group.  This is used by repmgr internal
* election processing.  For base replication, nsites
* is simply passed back to main for use in its
* communications and election processing.
*/
if (is_repmgr && setup_info->nsites > 0 &&
(ret = dbenv->rep_set_nsites(dbenv,
setup_info->nsites)) != 0) {
dbenv->err(dbenv, ret,
“Could not set nsites.\n”);
goto err;
}
break;
case ‘p’:
priority = atoi(optarg);
break;
case ‘R’:
if (!is_repmgr)
usage(is_repmgr, setup_info->progname);
site.peer = 1; /* FALLTHROUGH */
case ‘r’:
site.host = optarg;
site.host = strtok(site.host, “:”);
if ((portstr = strtok(NULL, “:”)) == NULL) {
fprintf(stderr, “Bad host specification.\n”);
goto err;
}
site.port = (unsigned short)atoi(portstr);
if (setup_info->site_list == NULL ||
setup_info->remotesites >= maxsites) {
maxsites = maxsites == 0 ? 10 : 2 * maxsites;
if ((setup_info->site_list =
realloc(setup_info->site_list,
maxsites * sizeof(repsite_t))) == NULL) {
fprintf(stderr, “System error %s\n”,
strerror(errno));
goto err;
}
}
(setup_info->site_list)[(setup_info->remotesites)++] =
site;
site.peer = 0;
break;
case ‘v’:
if ((ret = dbenv->set_verbose(dbenv,
DB_VERB_REPLICATION, 1)) != 0)
goto err;
break;
case ‘?’:
default:
usage(is_repmgr, setup_info->progname);
}
}

/* Error check command line. */
if (!got_self || setup_info->home == NULL)
usage(is_repmgr, setup_info->progname);
if (!is_repmgr && setup_info->role == UNKNOWN) {
fprintf(stderr, “Must specify -M or -C.\n”);
goto err;
}

/*
* Set replication group election priority for this environment.
* An election first selects the site with the most recent log
* records as the new master.  If multiple sites have the most
* recent log records, the site with the highest priority value
* is selected as master.
*/
if ((ret = dbenv->rep_set_priority(dbenv, priority)) != 0) {
dbenv->err(dbenv, ret, “Could not set priority.\n”);
goto err;
}

/*
* 设置持久消息确认策略。
* For repmgr, set the policy that determines how master and client
* sites handle acknowledgement of replication messages needed for
* permanent records.  The default policy of “quorum” requires only
* a quorum of electable peers sufficient to ensure a permanent
* record remains durable if an election is held.  The “all” option
* requires all clients to acknowledge a permanent replication
* message instead.
*/
if (is_repmgr &&
(ret = dbenv->repmgr_set_ack_policy(dbenv, ack_policy)) != 0) {
dbenv->err(dbenv, ret, “Could not set ack policy.\n”);
goto err;
}

/*
* Set the threshold for the minimum and maximum time the client
* waits before requesting retransmission of a missing message.
* Base these values on the performance and load characteristics
* of the master and client host platforms as well as the round
* trip message time.
* 设置丢失的日志消息的重传时限。如果Berkeley DB发现有日志消息丢失，
* 比如它发现连续收到的两条日志消息并不连续，它会在等待20秒后请求
* 重传这条日志消息，如果仍然没有收到，它会加倍等待的时间，直到该
* 等待时间达到500秒。
*
* 在使用repmgr的时候，由于使用了TCP/IP协议，不可能丢失消息，
* 所以可以不设置；如果使用不可靠的传输协议比如udp，那么可以通过
* 设置这个时限，确保能够收到丢失的日志消息。也就是说，Berkeley DB
* 内部实现了一个确保不可靠传输协议可靠地传输数据的协议，这样如果
* 我们使用UDP协议来传输Berkeley DB replication消息，那么丢包和
* 包错序不会影响Berkeley DB replication 的正常工作。
*/
if ((ret = dbenv->rep_set_request(dbenv, 20000, 500000)) != 0) {
dbenv->err(dbenv, ret,
“Could not set client_retransmission defaults.\n”);
goto err;
}

/*
* Configure deadlock detection to ensure that any deadlocks
* are broken by having one of the conflicting lock requests
* rejected. DB_LOCK_DEFAULT uses the lock policy specified
* at environment creation time or DB_LOCK_RANDOM if none was
* specified.
*/
if ((ret = dbenv->set_lk_detect(dbenv, DB_LOCK_DEFAULT)) != 0) {
dbenv->err(dbenv, ret,
“Could not configure deadlock detection.\n”);
goto err;
}

/* The following base replication features may also be useful to your
* application. See Berkeley DB documentation for more details.
*   – Master leases: Provide stricter consistency for data reads
*     on a master site.
*   – Timeouts: Customize the amount of time Berkeley DB waits
*     for such things as an election to be concluded or a master
*     lease to be granted.
*   – Delayed client synchronization: Manage the master site’s
*     resources by spreading out resource-intensive client
*     synchronizations.
*   – Blocked client operations: Return immediately with an error
*     instead of waiting indefinitely if a client operation is
*     blocked by an ongoing client synchronization.
*/

err:
return (ret);
}

static int
print_stocks(dbp)
DB *dbp;
{
DBC *dbc;
DBT key, data;
#define MAXKEYSIZE 10
#define MAXDATASIZE 20
char keybuf[MAXKEYSIZE + 1], databuf[MAXDATASIZE + 1];
int ret, t_ret;
u_int32_t keysize, datasize;

/* 读取数据，打印数据库当中所有记录。这个函数可以在master和每一个
* replica上面执行。*/
if ((ret = dbp->cursor(dbp, NULL, &dbc, 0)) != 0) {
dbp->err(dbp, ret, “can’t open cursor”);
return (ret);
}

memset(&key, 0, sizeof(key));
memset(&data, 0, sizeof(data));

printf(“\tSymbol\tPrice\n”);
printf(“\t======\t=====\n”);
/* 无论master上面还是replica上面，都是用完全相同的方法读取数据。*/
for (ret = dbc->get(dbc, &key, &data, DB_FIRST);
ret == 0;
ret = dbc->get(dbc, &key, &data, DB_NEXT)) {
keysize = key.size > MAXKEYSIZE ? MAXKEYSIZE : key.size;
memcpy(keybuf, key.data, keysize);
keybuf[keysize] = ‘\0′;

datasize = data.size >= MAXDATASIZE ? MAXDATASIZE : data.size;
memcpy(databuf, data.data, datasize);
databuf[datasize] = ‘\0′;

printf(“\t%s\t%s\n”, keybuf, databuf);
}
printf(“\n”);
fflush(stdout);

if ((t_ret = dbc->close(dbc)) != 0 && ret == 0)
ret = t_ret;

switch (ret) {
case 0:
case DB_NOTFOUND:
case DB_LOCK_DEADLOCK:
return (0);
default:
return (ret);
}
}

/* Start checkpoint and log archive support threads. */
int
start_support_threads(dbenv, sup_args, ckp_thr, lga_thr)
DB_ENV *dbenv;
supthr_args *sup_args;
thread_t *ckp_thr;
thread_t *lga_thr;
{
int ret;

ret = 0;
if ((ret = thread_create(ckp_thr, NULL, checkpoint_thread,
sup_args)) != 0) {
dbenv->errx(dbenv, “can’t create checkpoint thread”);
goto err;
}
if ((ret = thread_create(lga_thr, NULL, log_archive_thread,
sup_args)) != 0)
dbenv->errx(dbenv, “can’t create log archive thread”);
err:
return (ret);

}

/* Wait for checkpoint and log archive support threads to finish. */
int
finish_support_threads(ckp_thr, lga_thr)
thread_t *ckp_thr;
thread_t *lga_thr;
{
void *ctstatus, *ltstatus;
int ret;

ret = 0;
if (thread_join(*lga_thr, &ltstatus) ||
thread_join(*ckp_thr, &ctstatus)) {
ret = -1;
goto err;
}
if ((uintptr_t)ltstatus != EXIT_SUCCESS ||
(uintptr_t)ctstatus != EXIT_SUCCESS)
ret = -1;
err:
return (ret);
}

#define BUFSIZE 1024

int
doloop(dbenv, shared_data)
DB_ENV *dbenv;
SHARED_DATA *shared_data;
{
DB *dbp;
DBT key, data;
char buf[BUFSIZE], *first, *price;
u_int32_t flags;
int ret;

dbp = NULL;
ret = 0;
memset(&key, 0, sizeof(key));
memset(&data, 0, sizeof(data));

for (;;) {
printf(“QUOTESERVER%s> “,
shared_data->is_master ? “” : ” (read-only)”);
fflush(stdout);

if (fgets(buf, sizeof(buf), stdin) == NULL)
break;

#define DELIM ” \t\n”
if ((first = strtok(&buf[0], DELIM)) == NULL) {
/* Blank input line. */
price = NULL;
} else if ((price = strtok(NULL, DELIM)) == NULL) {
/* Just one input token. */
if (strncmp(buf, “exit”, 4) == 0 ||
strncmp(buf, “quit”, 4) == 0) {
/*
* This makes the checkpoint and log
* archive threads stop.
*/
shared_data->app_finished = 1;
break;
}
dbenv->errx(dbenv, “Format: TICKER VALUE”);
continue;
} else {
/* Normal two-token input line. */
if (first != NULL && !shared_data->is_master) {
dbenv->errx(dbenv, “Can’t update at client”);
continue;
}
}

if (dbp == NULL) {
if ((ret = db_create(&dbp, dbenv, 0)) != 0)
return (ret);

flags = DB_AUTO_COMMIT;
/*
* Open database with DB_CREATE only if this is
* a master database.  A client database uses
* polling to attempt to open the database without
* DB_CREATE until it is successful. 由于数据库
* 的创建也是一个写入操作，所以，replica不应该自
* 己创建数据库，而是定期检查是否有数据库被创建
* 好。当master创建了数据库后，这个日志消息会到
* 达所有的replica上面，于是Berkeley DB的
* replication功能自动创建好这个数据库。
*
* This DB_CREATE polling logic can be simplified
* under some circumstances.  For example, if the
* application can be sure a database is already
* there, it would never need to open it with
* DB_CREATE.
*/
if (shared_data->is_master)
flags |= DB_CREATE;
if ((ret = dbp->open(dbp,
NULL, DATABASE, NULL, DB_BTREE, flags, 0)) != 0) {
if (ret == ENOENT) {
printf(
“No stock database yet available.\n”);
if ((ret = dbp->close(dbp, 0)) != 0) {
dbenv->err(dbenv, ret,
“DB->close”);
goto err;
}
dbp = NULL;
continue;
}
if (ret == DB_REP_HANDLE_DEAD ||
ret == DB_LOCK_DEADLOCK) {
dbenv->err(dbenv, ret,
“please retry the operation”);
dbp->close(dbp, DB_NOSYNC);
dbp = NULL;
continue;
}
dbenv->err(dbenv, ret, “DB->open”);
goto err;
}
}

if (first == NULL) {
/*
* If this is a client in the middle of
* synchronizing with the master, the client data
* is possibly stale and won’t be displayed until
* client synchronization is finished.  It is also
* possible to display the stale data if this is
* acceptable to the application.
*/
if (shared_data->in_client_sync)
printf(
“Cannot read data during client synchronization – please try again.\n”);
else
switch ((ret = print_stocks(dbp))) {
case 0:
break;
case DB_REP_HANDLE_DEAD:
(void)dbp->close(dbp, DB_NOSYNC);
dbp = NULL;
break;
default:
dbp->err(dbp, ret,
“Error traversing data”);
goto err;
}
} else {
key.data = first;
key.size = (u_int32_t)strlen(first);

data.data = price;
data.size = (u_int32_t)strlen(price);

if ((ret = dbp->put(dbp,
NULL, &key, &data, DB_AUTO_COMMIT)) != 0) {
dbp->err(dbp, ret, “DB->put”);
goto err;
}
}
}

err: if (dbp != NULL)
(void)dbp->close(dbp, DB_NOSYNC);
return (ret);
}

int
create_env(progname, dbenvp)
const char *progname;
DB_ENV **dbenvp;
{
DB_ENV *dbenv;
int ret;

if ((ret = db_env_create(&dbenv, 0)) != 0) {
fprintf(stderr, “can’t create env handle: %s\n”,
db_strerror(ret));
return (ret);
}

dbenv->set_errfile(dbenv, stderr);
dbenv->set_errpfx(dbenv, progname);

*dbenvp = dbenv;
return (0);
}

/* Open and configure an environment. */
int
env_init(dbenv, home)
DB_ENV *dbenv;
const char *home;
{
u_int32_t flags;
int ret;

(void)dbenv->set_cachesize(dbenv, 0, CACHESIZE, 0);
(void)dbenv->set_flags(dbenv, DB_TXN_NOSYNC, 1);

flags = DB_CREATE | DB_INIT_LOCK | DB_INIT_LOG | DB_INIT_MPOOL |
DB_INIT_REP | DB_INIT_TXN | DB_RECOVER | DB_THREAD;
if ((ret = dbenv->open(dbenv, home, flags, 0)) != 0)
dbenv->err(dbenv, ret, “can’t open environment”);
return (ret);
}

/*
* In this application, we specify all communication via the command line.  In
* a real application, we would expect that information about the other sites
* in the system would be maintained in some sort of configuration file.  The
* critical part of this interface is that we assume at startup that we can
* find out
* 1) what host/port we wish to listen on for connections,
* 2) a (possibly empty) list of other sites we should attempt to connect
* to; and
* 3) what our Berkeley DB home environment is.
*
* These pieces of information are expressed by the following flags.
* -a all|quorum (optional; repmgr only, a stands for ack policy)
* -b (optional, b stands for bulk)
* -C or -M start up as client or master (optional for repmgr, required
*      for base example)
* -h home directory (required)
* -l host:port (required; l stands for local)
* -n nsites (optional; number of sites in replication group; defaults to 0
* in which case we try to dynamically compute the number of sites in
* the replication group)
* -p priority (optional: defaults to 100)
* -r host:port (optional; r stands for remote; any number of these may be
* specified)
* -R host:port (optional; repmgr only, remote peer)
* -v (optional; v stands for verbose)
*/
void
usage(is_repmgr, progname)
const int is_repmgr;
const char *progname;
{
fprintf(stderr, “usage: %s “, progname);
if (is_repmgr)
fprintf(stderr, “[-CM]-h home -l host:port[-r host:port]%s%s”,
“[-R host:port][-a all|quorum][-b][-n nsites]“,
“[-p priority][-v]\n”);
else
fprintf(stderr, “-CM -h home -l host:port[-r host:port]%s”,
“[-b][-n nsites][-p priority][-v]\n”);
exit(EXIT_FAILURE);
}

/*
* This is a very simple thread that performs checkpoints at a fixed
* time interval.  For a master site, the time interval is one minute
* plus the duration of the checkpoint_delay timeout (30 seconds by
* default.)  For a client site, the time interval is one minute.
*/
void *
checkpoint_thread(args)
void *args;
{
DB_ENV *dbenv;
SHARED_DATA *shared;
supthr_args *ca;
int i, ret;

ca = (supthr_args *)args;
dbenv = ca->dbenv;
shared = ca->shared;

for (;;) {
/*
* Wait for one minute, polling once per second to see if
* application has finished.  When application has finished,
* terminate this thread.
*/
for (i = 0; i < 60; i++) {
sleep(1);
if (shared->app_finished == 1)
return ((void *)EXIT_SUCCESS);
}

/* Perform a checkpoint. */
if ((ret = dbenv->txn_checkpoint(dbenv, 0, 0, 0)) != 0) {
dbenv->err(dbenv, ret,
“Could not perform checkpoint.\n”);
return ((void *)EXIT_FAILURE);
}
}
}

/*
* This is a simple log archive thread.  Once per minute, it removes all but
* the most recent 3 logs that are safe to remove according to a call to
* DB_ENV->log_archive().
*
* Log cleanup is needed to conserve disk space, but aggressive log cleanup
* can cause more frequent client initializations if a client lags too far
* behind the current master.  This can happen in the event of a slow client,
* a network partition, or a new master that has not kept as many logs as the
* previous master.
*
* The approach in this routine balances the need to mitigate against a
* lagging client by keeping a few more of the most recent unneeded logs
* with the need to conserve disk space by regularly cleaning up log files.
* Use of automatic log removal (DB_ENV->log_set_config() DB_LOG_AUTO_REMOVE
* flag) is not recommended for replication due to the risk of frequent
* client initializations.
*/
void *
log_archive_thread(args)
void *args;
{
DB_ENV *dbenv;
SHARED_DATA *shared;
char **begin, **list;
supthr_args *la;
int i, listlen, logs_to_keep, minlog, ret;

la = (supthr_args *)args;
dbenv = la->dbenv;
shared = la->shared;
logs_to_keep = 3;

for (;;) {
/*
* Wait for one minute, polling once per second to see if
* application has finished.  When application has finished,
* terminate this thread.
*/
for (i = 0; i < 60; i++) {
sleep(1);
if (shared->app_finished == 1)
return ((void *)EXIT_SUCCESS);
}

/* Get the list of unneeded log files. */
if ((ret = dbenv->log_archive(dbenv, &list, DB_ARCH_ABS))
!= 0) {
dbenv->err(dbenv, ret,
“Could not get log archive list.”);
return ((void *)EXIT_FAILURE);
}
if (list != NULL) {
listlen = 0;
/* Get the number of logs in the list. */
for (begin = list; *begin != NULL; begin++, listlen++);
/*
* Remove all but the logs_to_keep most recent
* unneeded log files.
*/
minlog = listlen – logs_to_keep;
for (begin = list, i= 0; i < minlog; list++, i++) {
if ((ret = unlink(*list)) != 0) {
dbenv->err(dbenv, ret,
“logclean: remove %s”, *list);
dbenv->errx(dbenv,
“logclean: Error remove %s”, *list);
free(begin);
return ((void *)EXIT_FAILURE);
}
}
free(begin);
}
}
}

STL API 就是为了增强Berkeley DB
的易用性而设计的。使用Berkeley DB STL API, 你就好像在使用C++ STL类库
一样：你操纵的是容器和iterator, 向容器中插入数据，数据就插入到了
Berkeley DB数据库中;使用iterator遍历容器，就可以遍历数据库中的数据。
而且你不需要与Dbt, Dbc, DbTxn等类型的对象打交道，不需要每次存储或者
读取数据，都封装到一个Dbt对象(也叫做marshal)，或者从Dbt对象中读取出
数据(也叫做unmarshal)。你只需要像使用C++ STL容器类和
iterator那样使用dbstl，就可以插入/删除/更新/查询 Berkeley DB数据库；
同时，你也不需要手动关闭cursor, transaction,
database, environment，还要保证正确的关闭顺序 — 它们的生命周期由
dbstl自动正确地管理。

dbstl被设计成几乎完全符合C++ STL规范，所以你可以像使用C++ STL
的容器和iterator那样使用 dbstl. 比如它的iterator符合C++ STL 的
规定，这样，c++ STL的算法就可以通过STL API
操纵Berkeley DB中的数据; c++ STL 的 container adapters, 诸如std::stack,
std::queue和std::priority_queue可以使用dbstl::db_vector 容器，这样
我们就可以非常轻易地用Berkeley DB数据库建立栈，队列，优先级队列。事实上，
如果你有一段使用了C++ STL的代码，你只需要替换容器类模板的名称，
以及其他一些微小的改动，你就可以使用dbstl了。

Dbstl的性能开销很小，而且有较好的可移植性。只要一个平台支持Berkeley DB，
并且拥有一个符合ISO C++标准的编译器，就一定可以使用dbstl. gcc3.4.4及以上，
intel c++ compiler 9及以上，以及msvc8，都是经验正支持dbstl的编译器。而且
dbstl通过了MS的STL测试包，以及SGI STL的测试包, 也就是说，它是符合C++ STL
标准的，你完全可以当dbstl是一个标准的c++ STL类库来使用它。

DB STL 的典型用例:
1. 当你的程序操纵着很大量的数据，无法容纳在内存当中的时候。此时C++ STL
会导致频繁的操作系统页交换，使得整台机器性能显著下降；如果使用dbstl,那么
由于Berkeley DB的缓存管理功能，只有用到的数据被保留在内存当中，
所以机器的全局性能不会受到任何影响。

2. 你希望使用一个熟悉的接口来使用Berkeley DB.
dbstl为Berkeley DB提供了一个熟悉的接口，因为几乎每一个c++程序员都接触过STL类库。
Berkeley DB特有的繁琐的DBT, DBC, DB_TXN等等的操作都被隐藏起来了。

3. 你需要拥有事务语义的数据结构。dbstl可选的提供了事务的ACID属性，并且支持全部的
C++ STL 容器功能。

4. 并发的访问控制
目前几乎所有的C++ STL实现只支持并发访问一个容器类的不同的容器对象。当你需要并发
地访问同一个容器对象时候，都需要显式的mutex保护。而使用dbstl的话，你就可以并发
地在多线程当中访问同一个容器对象，甚至并发地在多个进程当中通过各个进程当中的
容器对象操纵同一个数据库，并发访问的灵活性大大增加。

5. 对象持久化
dbstl允许你的程序在数据库中存储对象，并且在你的程序的多次运行之间存储和复活对象。
而且在用户提供适当的回调函数后，dbstl可以存储任意复杂的对象。

作为dbstl的主要设计和开发者， 毫不夸张地说，目前我是这个世界上最熟悉dbstl的人了，呵呵。
欢迎使用Berkeley DB的这个新功能，如果遇到问题可以在这里问我，或者到
Oracle Technology Network上面的Berkeley DB版面提问。

附注：
dbstl的参考文档: http://www.oracle.com/technology/documentation/berkeley-db/db/programmer_reference/index.html  的第 7 章

dbstl 的类/函数 文档： http://www.oracle.com/technology/documentation/berkeley-db/db/api_reference/STL/frame_main.html

dbstl示例代码： Berkeley DB source root/examples_stl里面有若干个示例程序；在 Berkeley DB source root/test_stl/base 里面，有针对dbstl的所有功能点的测试代码，可以作为学习使用dbstl的功能的示例代码。

Today I ran into a very interesting situation: I have a hg repository R on a server S,
and I cloned two copies from it, one is also on S, let’s call it B; The other on
my PC, let’s call it C. And I didn’t know that I actually cloned C from B, rather
than R, as how people usually worked. I could do so because mercurial is a distributed
version control system, each copy of repository has enough and all information about
the entire repository of the group.

However, I could do hg pull/hg commit/hg push in C, though I have been doing so to
B rather than R, and it is OK, as explained above. And I sometime later discovered
this situation when I did “hg pull -u” on B, believing B’s working copy would be
updated from R since I had already pushed to R from C, but B wasn’t updated.
Then I realized my repo address in C may be wrong, and yes, it was not R but B.
Then, I did “hg commit” followed by “hg push” in B, the two actions pushed all
changes which were committed by C into B, into R this time. And since B already had the
changes in its local repo, I can do a “hg update” to update its working source,
so that now B’s working source also have the latest code.

And then I update C’s repo address to use R instead, then all C’s commits goes to R, and
I can do “hg pull -u” in B to update B’s local repo and working copy, as
people normally work.

That is to say, any mercurial repository can be a central repo, for other
repos to do hg clone, hg commit or hg push; each local repo is equal to the central repo,
all repos including the “central” repo are working as identical and equal peers,
rather than working in a “client/server” mode like cvs, where clients can’t be
a server. Actually this “central” repo is only put there for ease of use in a group, the
group can work well if that “central” repo was some group member’s local repo;

I think the above situation is a vivid example of mercurial’s being a distributed
source control system.

PS:

1. Another important thing to note:

Although we can apply a patch generated from “hg diff” using the GNU patch utility, instead
of using hg import –no-commit, hg import –no-commit sometimes can not be replaced
by the GNU patch utility. For example, when a patch involves a change made by
“hg add”, “hg remove” or “hg rename” commands.

When applying such a patch to the working source code, we must use “hg import –no-commit”,
otherwise, the change may not appear in the working source directory.

2. We need to set the following to our local repo’s .hg/hgrc file:

[diff]
git = 1

Without the above setting, when you do “hg rename F”, the changes generated simply
consists of the changes which would be generated by “hg remove F” followed by “hg add F”.
Such a change is not only lengthy, but also confusing.

With the above setting, the “hg rename” command won’t be generating such stupid changeset,
it simply marks the file F’s name has changed, only two lines in the changeset.

事实上IEs4Linux应该存在了很长一段时间了，我应该早点去找到它的，有一种相见恨晚的感觉！这个世界上有如此多的有才能而又乐于贡献的程序员，以至于当我们有需求的时候，似乎总能够找到解决方案，真是太好了！

这样，我可以在Linux上面使用qq和IE了，也就意味着我可以完全不使用Windows了，除了下面两种情形：
1. 需要使用MSVC。
2. 需要使用淘宝等在线支付工具，以及其他银行的安全控件。因为毕竟IEs4Linux没有法律保障，呵呵。

总之，98%的用例已经可以由我的Linux满足了，而且我的工作效率还会大大提升，确实是一个不错的选择！

In this article I’d like to talk about the caveats and how-to’s when doing performance test with Berkeley DB, when the data volume is huge. For legal reasons I can not publish the result of my test without further approval, so I decided not to do so.

I. Context

I need to insert 10 billion key/data pairs to a btree database, each key item is 768 bytes, with no duplicate keys, and keys are inserted increasing only; each data item varies between KB/2 to 1KB. Thus each key/data pair varies between 1.25KB to 2KB.

After insertion, I search for some keys, some keys are in the db, others not, to find out the average time to insert a key/data pair, and to find a key/data pair. I use a very powerful Linux 64bit machine, which has 4 processers, each processor is a 3.2GB intel Xeon, 8GB memory and 8TB of storage.

II. Things to Note

The specially huge data volumn means a lot in this test, there are many things to note:

1. Integer overflow.
Loop variables will overflow if we insert so many key/data pairs in a loop, so split the job into pieces, making sure each piece of job won’t overflow an 32bit integer. If you used signed loop variables, they can go negative before reaching the limit value, and thus falls into an endless loop. In such a use case, we should be very careful about all integer variables being overflown.

Another example: If using 32bit integer as index keys, they are also overflown, causing not as many key/data pairs inserted as assumed, because later key/data pairs with keys already present in db will overwrite previous ones.

So we must use DB_SEQUENCE to generate 64bit sequential keys.

2. Random integer generator (rand() C function) loses randomness.
The RAND_MAX is only 64K, and when over 32K random integers are generated, the randomness fades, and I observed some none-randomness in my test code.

3. Huge key/data pair.

Context:
Each key/data pair can be as large as 2KB, and there can be millions of pages.

Problem:
A lot of overflow pages can be generated if using default page size.
Solution:
Set page size to 64k, so that each internal node can hold most number of keys, thus, the internal space waste, the number of times to read more internal nodes during search and the number of overflown pages is minimized. Concurrency is not harmed since each key/data pair is so big.

Problem:
Stack space insufficient.
Solution:
Do not allocate huge buffer (more than several MB) on stack, allocate it on heap, otherwise the stack may not be big enough.

4. Berkeley DB configuration

a. Do not use logs, otherwise, we will have to store another copy of the dataset, which is too much in this case as we are inserting 10 billion records each can be 3KB/4 to 2KB size.

b. Need a huge cache, otherwise the internal nodes won’t fit into the cache, btree search would be too slow.

c. When cache size is set to 6G on seneca, if using DB_PRIVATE, it is very slow, cpu usage is always less than 10%, because virtual memory (backed by disk) is used; when turned to use file mapping, cpu usage can be over 70%(later observation shows that cpu usage falls back to less than 10% after several millions of key/data pair are inserted, only when key/data pairs are inserted in order, did the insertion became fast. This is practical though, since we can always find sequentially increasing keys to use, and we can rely on secondary keys to use the various real keys.), the program is much faster.

d. May need to start multiple processes and insert simultaneously. And may need to split the cache into multiple files on some platforms which limit the maximum file size.

e. Use partitioned database, so that each database file is not so huge. If using multiple processes at the same time, each process inserting in one db file, concurrency can be promoted a lot. Though here I only used one process.

5. When changed to use ordered (increasing) keys, the insertion is much faster, as expected, because search becomes a very cheap operation in this case. In such a huge dataset, always use predictable sequentially increasing keys, like sequence numbers(1, 2, 3, …). For example we want to insert many Person objects, each of which has an ‘ID’ field, though we can not get Person objects ordered by ‘ID’, then we should use a sequence as the key for primary db containing Person objects, and create secondary databases each of which uses one of the properties of Person. The ‘ID’ secondary db is much smaller because the ‘data’ item of a key/data pair in it is only a sequence number, thus much easier and faster to find the Person object by its ID, and can insert very fast at the same time.

6. When the search phase begins, the pages are gradually loaded into cache, but since the keys were randomly chosen, the search is not fast. A lot of internal btree pages are being swapped in/out of the cache.

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.