Using of memory pool in hash table decreases the scalabiity

[wangli1426]

We use boost::pool in hash table to resolve the memory leak caused by fragment.
As boost::pool is not thread-safe, we have to use a spin-lock on the memory pool. This becomes the performance bottleneck when multiple thread are allocating hash buckets.

To solve this performance problem, I will first consider to use multiple pools in single hash table, such that one pool will only be used by a single thread. I expect this enhancement could hopefully improve the scalability.

[wangli1426]

The following is the comparison between the scalability of using one pool and multiple pool.

Number of thread	All threads sharing one pool	Each thread has a pool
1	1	1
2	1.5	1.6
3	1.9	2
4	2	2.5

The test is made by generating data and inserting into hash table. The configures are:

    const unsigned nbuckets=1024*1024;
    const unsigned tuple_size=32;
    const unsigned bucketsize=1024-8;
    const unsigned long data_size_in_MB=256;

The inserting code is like the following:

    while(arg.buffer->getBlock(*fetched_block)){
        void* tuple;
        BlockStreamBase::BlockStreamTraverseIterator* it=fetched_block->createIterator();
        while(tuple=it->nextTuple()){
            unsigned bn=arg.schema->columns[0].operate->getPartitionValue(tuple,arg.hash);
            void* new_tuple_in_hashtable=(*arg.hash_table)->atomicAllocate(bn,arg.tid);
            arg.schema->copyTuple(tuple,new_tuple_in_hashtable);
        }
    }