Modern C++ Design 笔记 第四章 Small-Object Allocation

在频繁的new/delete的时候容易衍生memory fragment, 我想设计这个Allocator的初衷就在这里。

初看到这个题目的时候不由的让人联想到的东西是std::allocator.

 

所以我们就从MS的STL中看看std::allocator的实现。

1. template<class _Ty> inline
2.     _Ty _FARQ *_Allocate(_SIZT _Count, _Ty _FARQ *)
3.     {   // check for integer overflow
4.     if (_Count <= 0)
5.         _Count = 0;
6.     else if (((_SIZT)(-1) / _Count) < sizeof (_Ty))
7.         _THROW_NCEE(std::bad_alloc, NULL);
8. 
   
9.         // allocate storage for _Count elements of type _Ty
10.     return ((_Ty _FARQ *)::operator new(_Count * sizeof (_Ty)));
11.     }
12. 
    
13. void deallocate(pointer _Ptr, size_type)
14.     {   // deallocate object at _Ptr, ignore size
15.         ::operator delete(_Ptr);
16.     }
17. 
    
18. pointer allocate(size_type _Count)
19.     {   // allocate array of _Count elements
20.         return (_Allocate(_Count, (pointer)0));
21.     }

可以看到这里遵循了STL的标准但是做到的就是把allocator和deallocate做了new/delete最基本的wrapper.

随后由于受到侯捷的<<STL源码剖析>>的“毒害”：），自然要看看SGI STL的策略的。SGI确实还是要高级不少的。具体的实现从__default_alloc_template这个类就可以看出一点端倪。

1.   /* __n must be > 0      */
2.   static void* allocate(size_t __n)
3.   {
4.     void* __ret = 0;
5. 
   
6.     if (__n > (size_t) _MAX_BYTES) {
7.       __ret = malloc_alloc::allocate(__n);
8.     }
9.     else {
10.       _Obj* __STL_VOLATILE* __my_free_list
11.           = _S_free_list + _S_freelist_index(__n);
12.       // Acquire the lock here with a constructor call.
13.       // This ensures that it is released in exit or during stack
14.       // unwinding.
15. #     ifndef _NOTHREADS
16.       /*REFERENCED*/
17.       _Lock __lock_instance;
18. #     endif
19.       _Obj* __RESTRICT __result = *__my_free_list;
20.       if (__result == 0)
21.         __ret = _S_refill(_S_round_up(__n));
22.       else {
23.         *__my_free_list = __result -> _M_free_list_link;
24.         __ret = __result;
25.       }
26.     }
27. 
    
28.     return __ret;
29.   };
30. 
    
31.   /* __p may not be 0 */
32.   static void deallocate(void* __p, size_t __n)
33.   {
34.     if (__n > (size_t) _MAX_BYTES)
35.       malloc_alloc::deallocate(__p, __n);
36.     else {
37.       _Obj* __STL_VOLATILE*  __my_free_list
38.           = _S_free_list + _S_freelist_index(__n);
39.       _Obj* __q = (_Obj*)__p;
40. 
    
41.       // acquire lock
42. #       ifndef _NOTHREADS
43.       /*REFERENCED*/
44.       _Lock __lock_instance;
45. #       endif /* _NOTHREADS */
46.       __q -> _M_free_list_link = *__my_free_list;
47.       *__my_free_list = __q;
48.       // lock is released here
49.     }
50.   }

这里虽然仅仅贴出了allocator和deallocator的代码，但是也可以看出一点端倪了。首先可以肯定的是这里不再简单的是new/delete了， 这里加入了一些特殊的逻辑来管理内存，大致上就是FreeListLink辅之以一个memeory pool.每次的特定大小的内存分配都可以到FreeList对应的node里面去找。这个list的node对应的就是小于等于128byte的各个8倍数。实际上就是8,16,24,32,40,48,56,64,72,80,88,96,104,112,120,128。如果list node中存在就直接拿好了， 如果没有就 _S_refill一下，这里 _S_refill的实现大致上就是从Memory Pool中去读取了。这里就不展开了：）

说了这么多废话，现在回到这个我们的Loki lib中的small-object allocator,这个allocator的特点在什么地方呢。中国人看问题的方式可能和老外不同，至少和这本书介绍的方式不同，我们喜欢所谓透过现象看本质的流程。在层次上这里的模型大概分成Chunk, FixedAllocator, SmallObjAllocator和SmallObject。 在最上层的使用者就是SmallObject，让我们撇开复杂的模型中和内存策略无关的singleton包装，直接看到SmallObjAllocator中allocate和deallocate的实现。

1. // SmallObjAllocator::Allocate ------------------------------------------------
2. 
   
3. void * SmallObjAllocator::Allocate( std::size_t numBytes, bool doThrow )
4. {
5.     if ( numBytes > GetMaxObjectSize() )
6.         return DefaultAllocator( numBytes, doThrow );
7. 
   
8.     assert( NULL != pool_ );
9.     if ( 0 == numBytes ) numBytes = 1;
10.     const std::size_t index = GetOffset( numBytes, GetAlignment() ) - 1;
11.     const std::size_t allocCount = GetOffset( GetMaxObjectSize(), GetAlignment() );
12.     (void) allocCount;
13.     assert( index < allocCount );
14. 
    
15.     FixedAllocator & allocator = pool_[ index ];
16.     assert( allocator.BlockSize() >= numBytes );
17.     assert( allocator.BlockSize() < numBytes + GetAlignment() );
18.     void * place = allocator.Allocate();
19. 
    
20.     if ( ( NULL == place ) && TrimExcessMemory() )
21.         place = allocator.Allocate();
22. 
    
23.     if ( ( NULL == place ) && doThrow )
24.     {
25. #ifdef _MSC_VER
26.         throw std::bad_alloc( "could not allocate small object" );
27. #else
28.         // GCC did not like a literal string passed to std::bad_alloc.
29.         // so just throw the default-constructed exception.
30.         throw std::bad_alloc();
31. #endif
32.     }
33.     return place;
34. }
35. 
    
36. // SmallObjAllocator::Deallocate ----------------------------------------------
37. 
    
38. void SmallObjAllocator::Deallocate( void * p, std::size_t numBytes )
39. {
40.     if ( NULL == p ) return;
41.     if ( numBytes > GetMaxObjectSize() )
42.     {
43.         DefaultDeallocator( p );
44.         return;
45.     }
46.     assert( NULL != pool_ );
47.     if ( 0 == numBytes ) numBytes = 1;
48.     const std::size_t index = GetOffset( numBytes, GetAlignment() ) - 1;
49.     const std::size_t allocCount = GetOffset( GetMaxObjectSize(), GetAlignment() );
50.     (void) allocCount;
51.     assert( index < allocCount );
52.     FixedAllocator & allocator = pool_[ index ];
53.     assert( allocator.BlockSize() >= numBytes );
54.     assert( allocator.BlockSize() < numBytes + GetAlignment() );
55.     const bool found = allocator.Deallocate( p, NULL );
56.     (void) found;
57.     assert( found );
58. }

首先可以看到的是这里的分配都是依靠 pool_来实现的， 这里的 pool_最初的定义如书中的描述是std::vector<FixedAllocator> pool_;但是现在已经退化成了 FixedAllocator* pool_;其实从现在的实现来看却是没有vector的必要。能够发现的是，同样2种实现都可以到达常数时间找到对应allocator。(其实这点很重，在SGI的freelist也有类似的接口做到了这一点)。找到之后的分配就完全靠他了。

同时我们可以看看这个pool的实例化的过程：

1. SmallObjAllocator::SmallObjAllocator( std::size_t pageSize,
2.     std::size_t maxObjectSize, std::size_t objectAlignSize ) :
3.     pool_( NULL ),
4.     maxSmallObjectSize_( maxObjectSize ),
5.     objectAlignSize_( objectAlignSize )
6. {
7. #ifdef DO_EXTRA_LOKI_TESTS
8.     std::cout << "SmallObjAllocator " << this << std::endl;
9. #endif
10.     assert( 0 != objectAlignSize );
11.     const std::size_t allocCount = GetOffset( maxObjectSize, objectAlignSize );
12.     pool_ = new FixedAllocator[ allocCount ];
13.     for ( std::size_t i = 0; i < allocCount; ++i )
14.         pool_[ i ].Initialize( ( i+1 ) * objectAlignSize, pageSize );
15. }

这里的Initialize并不会把实际的内存都分配好，而只是设定下alignment， 和maxSize， 这里的maxSize就像SGI STL中的那个128, 就是我这个small-object allocator会分配的内存大小最多就是128bytes.当然这里的分配器就比SGI STL稍稍灵活了一点。

总结一点，这里的SmallObjAllocator同样地 ，首先要看需要分配的内存的大小有多大， 确定下来size之后常数时间去pool_[ i ]中，实际上就是去FixedAllocator去获取。可以看到的是和SGI STL的模型非常类似:)现在我们来看看FixedAllocator是如何来操作具体的allocate/deallocate的。

1. // FixedAllocator::Allocate ---------------------------------------------------
2. 
   
3. void * FixedAllocator::Allocate( void )
4. {
5.     // prove either emptyChunk_ points nowhere, or points to a truly empty Chunk.
6.     assert( ( NULL == emptyChunk_ ) || ( emptyChunk_->HasAvailable( numBlocks_ ) ) );
7.     assert( CountEmptyChunks() < 2 );
8. 
   
9.     if ( ( NULL == allocChunk_ ) || allocChunk_->IsFilled() )
10.     {
11.         if ( NULL != emptyChunk_ )
12.         {
13.             allocChunk_ = emptyChunk_;
14.             emptyChunk_ = NULL;
15.         }
16.         else
17.         {
18.             for ( ChunkIter i( chunks_.begin() ); ; ++i )
19.             {
20.                 if ( chunks_.end() == i )
21.                 {
22.                     if ( !MakeNewChunk() )
23.                         return NULL;
24.                     break;
25.                 }
26.                 if ( !i->IsFilled() )
27.                 {
28.                     allocChunk_ = &*i;
29.                     break;
30.                 }
31.             }
32.         }
33.     }
34.     else if ( allocChunk_ == emptyChunk_)
35.         // detach emptyChunk_ from allocChunk_, because after 
36.         // calling allocChunk_->Allocate(blockSize_); the chunk 
37.         // is no longer empty.
38.         emptyChunk_ = NULL;
39. 
    
40.     assert( allocChunk_ != NULL );
41.     assert( !allocChunk_->IsFilled() );
42.     void * place = allocChunk_->Allocate( blockSize_ );
43. 
    
44.     // prove either emptyChunk_ points nowhere, or points to a truly empty Chunk.
45.     assert( ( NULL == emptyChunk_ ) || ( emptyChunk_->HasAvailable( numBlocks_ ) ) );
46.     assert( CountEmptyChunks() < 2 );
47. 
    
48.     return place;
49. }
50. 
    
51. // FixedAllocator::Deallocate -------------------------------------------------
52. 
    
53. bool FixedAllocator::Deallocate( void * p, Chunk * hint )
54. {
55.     assert(!chunks_.empty());
56.     assert(&chunks_.front() <= deallocChunk_);
57.     assert(&chunks_.back() >= deallocChunk_);
58.     assert( &chunks_.front() <= allocChunk_ );
59.     assert( &chunks_.back() >= allocChunk_ );
60.     assert( CountEmptyChunks() < 2 );
61. 
    
62.     Chunk * foundChunk = ( NULL == hint ) ? VicinityFind( p ) : hint;
63.     if ( NULL == foundChunk )
64.         return false;
65. 
    
66.     assert( foundChunk->HasBlock( p, numBlocks_ * blockSize_ ) );
67. #ifdef LOKI_CHECK_FOR_CORRUPTION
68.     if ( foundChunk->IsCorrupt( numBlocks_, blockSize_, true ) )
69.     {
70.         assert( false );
71.         return false;
72.     }
73.     if ( foundChunk->IsBlockAvailable( p, numBlocks_, blockSize_ ) )
74.     {
75.         assert( false );
76.         return false;
77.     }
78. #endif
79.     deallocChunk_ = foundChunk;
80.     DoDeallocate(p);
81.     assert( CountEmptyChunks() < 2 );
82. 
    
83.     return true;
84. }

进一步这里可以看到很多所谓Chunk的身影了，这里具体的alloc的任务就是Chunk来完成的，不同于 FixedAllocator的是这里的chunks_被定义成了std::vector< Chunk >，因为这里的长度就会发生变化了。因为实际上一个确定了blockSize的Chunk的实际大小是固定的，所以就需要很多个Chunk来完成特定量的分配。 （但是数组是不在这个讨论范围内的）。比如说你需要257个8个byte的内存块， 问题来了Chunk的特性决定了他的块的数量最大是256，所以，只能能有2个Chunk来完成，也就是这里有个Chunk数组的原因。

这里的Chunk的实现类似月SGI STL中的Union OBJ，同样的为了避免额外的标记内存的指针或者数字，SGI STL中采取了Union的方式来共用内存，而Chunk则直接使用了分配内存中的一个byte（或者说一个char）来标记分配的情况。还是看图最直观：

Chunk中维护了一段内存，pData_一个index和一个count，使用这些东西就可以满足要求了。很显然的是每次分配一个block，就把firstAvailableBlock_++,然后blocksAvailable_--，firstAvailableBlock_加上pData就可以常数时间找到空闲的内存了。又是常数时间， 呵呵。而且这些内存不会有额外的浪费分配。现在的体会只有用impressive可以形容啦。