CPPFormatLibary提升效率的优化原理
CPPFormatLibary，以下简称FL，介绍：关于CPPFormatLibary。
与stringstream，甚至C库的sprintf系列想比，FL在速度上都有优势，而且是在支持.net格式化风格的基础上。要实现这一点，需要多种优化结合在一起，有代码技巧方面的，也有设计策略上的。下面简要的对这些内容进行讲解：
1. Pattern缓存
在C库函数sprintf中，比如这行代码：
1 char szBuf[64]; 2 sprintf_s(szBuf, "%d--#--%8.2f--#--%s", 100, -40.2f, " String ");
格式化字符串"%d--#--%8.2f--#--%s"在每次函数调用的时候，都需要分析一次，依次找出对应的格式化符，在实际开发过程中，多数情况下，格式化字符串并没有任何不同，因此这个分析属于重复分析。因此在设计FL时将这样的格式化字符串称为PatternList，并使用Hash容器对这个PatternList进行存储，在每次格式化之前，首先在容器中查找对应字符串的Pattern是否已经存在，有的话则直接使用已经分析的结果。
下面的代码是Pattern的定义，PatternList则为对应的数组：
1 /** 2 * @brief This is the description of a Format unit 3 * @example {0} {0:d} 4 */ 5 template < typename TCharType > 6 class TFormatPattern 7 { 8 public: 9 typedef TCharType CharType; 10 typedef unsigned char ByteType; 11 typedef std::size_t SizeType; 12 13 enum EFormatFlag 14 { 15 FF_Raw, 16 FF_None, 17 FF_Decimal, 18 FF_Exponent, 19 FF_FixedPoint, 20 FF_General, 21 FF_CSV, 22 FF_Percentage, 23 FF_Hex 24 }; 25 26 enum EAlignFlag 27 { 28 AF_Right, 29 AF_Left 30 }; 31 32 TFormatPattern() : 33 Start((SizeType)-1), 34 Len(0), 35 Flag(FF_Raw), 36 Align(AF_Right), 37 Index((ByteType)-1), 38 Precision((ByteType)-1), 39 Width((ByteType)-1) 40 41 { 42 } 43 44 SizeType GetLegnth() const 45 { 46 return Len; 47 } 48 49 bool IsValid() const 50 { 51 return Start != -1 && Len != -1 && Index >= 0; 52 } 53 54 bool HasWidth() const 55 { 56 return Width != (ByteType)-1; 57 } 58 59 bool HasPrecision() const 60 { 61 return Precision != (ByteType)-1; 62 } 63 64 public: 65 SizeType Start; 66 SizeType Len; 67 EFormatFlag Flag; 68 EAlignFlag Align; 69 70 ByteType Index; 71 ByteType Precision; 72 ByteType Width; 73 };
这个Pattern就代表了分析格式化字符串的每一个单元。
1 StandardLibrary::FormatTo(str, "{0}--#--{1,8}--#--{2}", 100, -40.2f, " String ");
在这行代码中，PatternList一共有5个Pattern，分别是：
{0} 参数0
--#-- 原始类型
{1,8} 参数1 宽度8
--#-- 原始类型 纯字符串
{2} 参数2
这样设计可以优化掉重复的字符串Parse。
2.各种类型到字符串转换的算法优化
这部分代码完全存在于文件Algorithm.hpp中，这里面包含了诸如int、double等转换为字符串的快速算法，实测性能优于sprintf和atoi之类。通过这些基础算法的优化，性能可以得到相当不错的提升。
1 template < typename TCharType > 2 inline void StringReverse(TCharType* Start, TCharType* End) 3 { 4 TCharType Aux; 5 6 while (Start < End) 7 { 8 Aux = *End; 9 *End-- = *Start; 10 *Start++ = Aux; 11 } 12 } 13 14 namespace Detail 15 { 16 const char DigitMap[] = 17 { 18 '0', '1', '2', '3', '4', '5', '6', 19 '7', '8', '9', 'A', 'B', 'C', 'D', 20 'E', 'F' 21 }; 22 } 23 24 template < typename TCharType > 25 inline SIZE_T Int64ToString(INT64 Value, TCharType* Buf, INT Base) 26 { 27 assert(Base > 0 && static_cast<SIZE_T>(Base) <= _countof(Detail::DigitMap)); 28 29 TCharType* Str = Buf; 30 31 UINT64 UValue = (Value < 0) ? -Value : Value; 32 33 // Conversion. Number is reversed. 34 do 35 { 36 *Str++ = Detail::DigitMap[UValue%Base]; 37 } while (UValue /= Base); 38 39 if (Value < 0) 40 { 41 *Str++ = '-'; 42 } 43 44 *Str = '\0'; 45 46 // Reverse string 47 StringReverse<TCharType>(Buf, Str - 1); 48 49 return Str - Buf; 50 }
上面这段代码展示的是快速整数到字符串的转换。据说基于sse指令的各种转换会更快，然而担心兼容性问题影响跨平台，我并未采用。
3. 栈容器和栈字符串
这部分代码存在于文件Utility.hpp中，这部分代码的优化原理就是在需要的动态内存并不大的时候，直接使用栈内存，当内存需求大到超过一定阀值的时候，自动申请堆内存并将栈数据转移到堆内存上。在大多数情况下，我们需要的内存都是很少，因此在绝大多数情况下，都能起到相当显著的优化效果。
1 template < 2 typename T, 3 INT DefaultLength = 0xFF, 4 INT ExtraLength = 0 5 > 6 class TAutoArray 7 { 8 public: 9 typedef TAutoArray<T, DefaultLength, ExtraLength> SelfType; 10 11 enum 12 { 13 DEFAULT_LENGTH = DefaultLength 14 }; 15 16 class ConstIterator : Noncopyable 17 { 18 public: 19 ConstIterator(const SelfType& InRef) : 20 Ref(InRef), 21 Index( InRef.GetLength()>0?0:-1 ) 22 { 23 } 24 25 bool IsValid() const 26 { 27 return Index < Ref.GetLength(); 28 } 29 30 bool Next() 31 { 32 ++Index; 33 34 return IsValid(); 35 } 36 37 const T& operator *() const 38 { 39 const T* Ptr = Ref.GetDataPtr(); 40 41 return Ptr[Index]; 42 } 43 private: 44 ConstIterator& operator = (const ConstIterator&); 45 ConstIterator(ConstIterator&); 46 protected: 47 const SelfType& Ref; 48 SIZE_T Index; 49 }; 50 51 TAutoArray() : 52 Count(0), 53 AllocatedCount(0), 54 HeapValPtr(NULL) 55 { 56 } 57 58 ~TAutoArray() 59 { 60 ReleaseHeapData(); 61 62 Count = 0; 63 } 64 65 TAutoArray(const SelfType& Other) : 66 Count(Other.Count), 67 AllocatedCount(Other.AllocatedCount), 68 HeapValPtr(NULL) 69 { 70 if (Count > 0) 71 { 72 if (Other.IsDataOnStack()) 73 { 74 Algorithm::CopyArray(Other.StackVal, Other.StackVal + Count, StackVal); 75 } 76 else 77 { 78 HeapValPtr = Allocate(AllocatedCount); 79 Algorithm::CopyArray(Other.HeapValPtr, Other.HeapValPtr + Count, HeapValPtr); 80 } 81 } 82 } 83 84 SelfType& operator = (const SelfType& Other) 85 { 86 if (this == &Other) 87 { 88 return *this; 89 } 90 91 ReleaseHeapData(); 92 93 Count = Other.Count; 94 AllocatedCount = Other.AllocatedCount; 95 HeapValPtr = NULL; 96 97 if (Count > 0) 98 { 99 if (Other.IsDataOnStack()) 100 { 101 Algorithm::CopyArray(Other.StackVal, Other.StackVal + Count, StackVal); 102 } 103 else 104 { 105 HeapValPtr = Allocate(AllocatedCount); 106 Algorithm::CopyArray(Other.HeapValPtr, Other.HeapValPtr + Count, HeapValPtr); 107 } 108 } 109 110 return *this; 111 } 112 113 SelfType& TakeFrom(SelfType& Other) 114 { 115 if (this == &Other) 116 { 117 return *this; 118 } 119 120 Count = Other.Count; 121 AllocatedCount = Other.AllocatedCount; 122 HeapValPtr = Other.HeapValPtr; 123 124 if (Count > 0 && Other.IsDataOnStack()) 125 { 126 Algorithm::MoveArray(Other.StackVal, Other.StackVal + Count, StackVal); 127 } 128 129 Other.Count = 0; 130 Other.AllocatedCount = 0; 131 Other.HeapValPtr = NULL; 132 } 133 134 void TakeTo(SelfType& Other) 135 { 136 Other.TakeFrom(*this); 137 } 138 139 #if FL_PLATFORM_HAS_RIGHT_VALUE_REFERENCE 140 TAutoArray( SelfType && Other ) : 141 Count(Other.Count), 142 AllocatedCount(Other.AllocatedCount), 143 HeapValPtr(Other.HeapValPtr) 144 { 145 if (Count > 0 && Other.IsDataOnStack()) 146 { 147 Algorithm::MoveArray(Other.StackVal, Other.StackVal + Count, StackVal); 148 } 149 150 Other.Count = 0; 151 Other.AllocatedCount = 0; 152 Other.HeapValPtr = NULL; 153 } 154 155 SelfType& operator = (SelfType&& Other ) 156 { 157 return TakeFrom(Other); 158 } 159 #endif 160 161 bool IsDataOnStack() const 162 { 163 return HeapValPtr == NULL; 164 } 165 166 void AddItem(const T& InValue) 167 { 168 if (IsDataOnStack()) 169 { 170 if (Count < DEFAULT_LENGTH) 171 { 172 StackVal[Count] = InValue; 173 ++Count; 174 } 175 else if (Count == DEFAULT_LENGTH) 176 { 177 InitialMoveDataToHeap(); 178 179 assert(Count < AllocatedCount); 180 181 HeapValPtr[Count] = InValue; 182 ++Count; 183 } 184 else 185 { 186 assert(false && "internal error"); 187 } 188 } 189 else 190 { 191 if (Count < AllocatedCount) 192 { 193 HeapValPtr[Count] = InValue; 194 ++Count; 195 } 196 else 197 { 198 ExpandHeapSpace(); 199 200 assert(Count < AllocatedCount); 201 HeapValPtr[Count] = InValue; 202 ++Count; 203 } 204 } 205 } 206 207 SIZE_T GetLength() const 208 { 209 return Count; 210 } 211 212 SIZE_T GetAllocatedCount() const 213 { 214 return AllocatedCount; 215 } 216 217 T* GetDataPtr() 218 { 219 return IsDataOnStack() ? StackVal : HeapValPtr; 220 } 221 222 const T* GetDataPtr() const 223 { 224 return IsDataOnStack() ? StackVal : HeapValPtr; 225 } 226 227 T* GetUnusedPtr() 228 { 229 return IsDataOnStack() ? StackVal + Count : HeapValPtr + Count; 230 } 231 232 const T* GetUnusedPtr() const 233 { 234 return IsDataOnStack() ? StackVal + Count : HeapValPtr + Count; 235 } 236 237 SIZE_T GetCapacity() const 238 { 239 return IsDataOnStack() ? 240 DEFAULT_LENGTH - Count : 241 AllocatedCount - Count; 242 } 243 244 T& operator []( SIZE_T Index ) 245 { 246 assert( Index < GetLength() ); 247 248 return GetDataPtr()[Index]; 249 } 250 251 const T& operator []( SIZE_T Index ) const 252 { 253 assert( Index < GetLength() ); 254 255 return GetDataPtr()[Index]; 256 } 257 258 protected: 259 void InitialMoveDataToHeap() 260 { 261 assert(HeapValPtr == NULL); 262 263 AllocatedCount = DEFAULT_LENGTH * 2; 264 265 HeapValPtr = Allocate(AllocatedCount); 266 267 #if FL_PLATFORM_HAS_RIGHT_VALUE_REFERENCE 268 Algorithm::MoveArray(StackVal, StackVal + Count, HeapValPtr); 269 #else 270 Algorithm::CopyArray(StackVal, StackVal + Count, HeapValPtr); 271 #endif 272 } 273 274 void ExpandHeapSpace() 275 { 276 SIZE_T NewCount = AllocatedCount * 2; 277 assert(NewCount > AllocatedCount); 278 279 T* DataPtr = Allocate(NewCount); 280 281 assert(DataPtr); 282 283 #if FL_PLATFORM_HAS_RIGHT_VALUE_REFERENCE 284 Algorithm::MoveArray(HeapValPtr, HeapValPtr + Count, DataPtr); 285 #else 286 Algorithm::CopyArray(HeapValPtr, HeapValPtr + Count, DataPtr); 287 #endif 288 ReleaseHeapData(); 289 290 HeapValPtr = DataPtr; 291 AllocatedCount = NewCount; 292 } 293 294 void ReleaseHeapData() 295 { 296 if (HeapValPtr) 297 { 298 delete[] HeapValPtr; 299 HeapValPtr = NULL; 300 } 301 302 AllocatedCount = 0; 303 } 304 305 static T* Allocate(const SIZE_T InAllocatedCount) 306 { 307 // +ExtraLength this is a hack method for saving string on it. 308 return new T[InAllocatedCount + ExtraLength]; 309 } 310 311 protected: 312 SIZE_T Count; 313 SIZE_T AllocatedCount; 314 315 // +ExtraLength this is a hack method for saving string on it. 316 T StackVal[DEFAULT_LENGTH + ExtraLength]; 317 318 T* HeapValPtr; 319 };
上面这段代码展示的就是这个设想的实现。这是一个模板类，基于这个类实现了栈字符串。同时默认的PatternList也是使用这个模板来保存的，这样在节约了大量的内存分配操作之后，性能得到进一步的提升。
1 // String Wrapper 2 template < typename TCharType > 3 class TAutoString : 4 public TAutoArray< TCharType, 0xFF, 2 > 5 { 6 public: 7 typedef TAutoArray< TCharType, 0xFF, 2 > Super; 8 typedef Mpl::TCharTraits<TCharType> CharTraits; 9 typedef TCharType CharType; 10 11 #if !FL_COMPILER_MSVC 12 using Super::Count; 13 using Super::AllocatedCount; 14 using Super::HeapValPtr; 15 using Super::StackVal; 16 using Super::Allocate; 17 using Super::IsDataOnStack; 18 using Super::DEFAULT_LENGTH; 19 using Super::GetDataPtr; 20 using Super::ReleaseHeapData; 21 #endif 22 23 TAutoString() 24 { 25 } 26 27 TAutoString(const CharType* pszStr) 28 { 29 if (pszStr) 30 { 31 const SIZE_T Length = CharTraits::length(pszStr); 32 33 Count = Length; 34 35 if (Length <= DEFAULT_LENGTH) 36 { 37 CharTraits::copy(pszStr, pszStr + Length, StackVal); 38 StackVal[Count] = 0; 39 } 40 else 41 { 42 HeapValPtr = Allocate(Length); 43 CharTraits::copy(pszStr, pszStr + Length, HeapValPtr); 44 HeapValPtr[Count] = 0; 45 } 46 } 47 } 48 49 void AddChar(CharType InValue) 50 { 51 AddItem(InValue); 52 53 if (IsDataOnStack()) 54 { 55 StackVal[Count] = 0; 56 } 57 else 58 { 59 HeapValPtr[Count] = 0; 60 } 61 } 62 63 void AddStr(const CharType* pszStart, const CharType* pszEnd = NULL) 64 { 65 const SIZE_T Length = pszEnd ? pszEnd - pszStart : CharTraits::length(pszStart); 66 67 if (IsDataOnStack()) 68 { 69 if (Count + Length <= DEFAULT_LENGTH) 70 { 71 CharTraits::copy(StackVal+Count, pszStart, Length); 72 Count += Length; 73 74 StackVal[Count] = 0; 75 } 76 else 77 { 78 assert(!HeapValPtr); 79 80 AllocatedCount = static_cast<SIZE_T>((Count + Length)*1.5f); 81 HeapValPtr = Allocate(AllocatedCount); 82 assert(HeapValPtr); 83 84 if (Count > 0) 85 { 86 CharTraits::copy(HeapValPtr, StackVal, Count); 87 } 88 89 CharTraits::copy(HeapValPtr+Count, pszStart, Length); 90 91 Count += Length; 92 93 HeapValPtr[Count] = 0; 94 } 95 } 96 else 97 { 98 if (Count + Length <= AllocatedCount) 99 { 100 CharTraits::copy(HeapValPtr+Count, pszStart, Length); 101 Count += Length; 102 103 HeapValPtr[Count] = 0; 104 } 105 else 106 { 107 SIZE_T NewCount = static_cast<SIZE_T>((Count + Length)*1.5f); 108 109 CharType* DataPtr = Allocate(NewCount); 110 111 if (Count > 0) 112 { 113 CharTraits::copy(DataPtr, HeapValPtr, Count); 114 } 115 116 ReleaseHeapData(); 117 118 CharTraits::copy(DataPtr, pszStart, Length); 119 120 Count += Length; 121 122 AllocatedCount = NewCount; 123 HeapValPtr = DataPtr; 124 125 HeapValPtr[Count] = 0; 126 } 127 } 128 } 129 130 const TCharType* CStr() const 131 { 132 return GetDataPtr(); 133 } 134 135 // is is a internal function 136 // 137 void InjectAdd(SIZE_T InCount) 138 { 139 Count += InCount; 140 141 assert(IsDataOnStack() ? (Count <= DEFAULT_LENGTH) : (Count < AllocatedCount)); 142 } 143 144 protected: 145 void AddItem(const TCharType& InValue) 146 { 147 Super::AddItem(InValue); 148 } 149 };
上面展示的是基于栈内存容器实现的栈字符串，在大多数情况下，我们格式化字符串时都采用栈字符串来保存结果，这样可以显著的提升性能。
同时栈容器和栈字符串，都特别适合于当临时容器和临时字符串，因为多数情况下它们都优化掉了可能需要动态内存分配的操作。所以它们的使用并不局限于这一个小地方。
4. 基于C++ 11的优化
除了引入了C++ 11的容器unordered_map之外，还引入了右值引用等新内容，在某些情况下，可以带来一定的性能提升。
1 #if FL_PLATFORM_HAS_RIGHT_VALUE_REFERENCE 2 TAutoArray( SelfType && Other ) : 3 Count(Other.Count), 4 AllocatedCount(Other.AllocatedCount), 5 HeapValPtr(Other.HeapValPtr) 6 { 7 if (Count > 0 && Other.IsDataOnStack()) 8 { 9 Algorithm::MoveArray(Other.StackVal, Other.StackVal + Count, StackVal); 10 } 11 12 Other.Count = 0; 13 Other.AllocatedCount = 0; 14 Other.HeapValPtr = NULL; 15 } 16 17 SelfType& operator = (SelfType&& Other ) 18 { 19 return TakeFrom(Other); 20 } 21 #endif
上面展示的是基于右值引用的优化。
除此之外还是用了线程局部存储(TLS)，这依赖于编译器是否支持。前面提到了我们采用Hash容器来存储Pattern缓存，然而在单线程的时候自然无需多余考虑，当需要支持多线程时，则全局唯一的Hash容器的访问都需要加锁，而加锁是有性能开销的。幸好C++ 11带来了内置的TLS支持，其结果就是每个线程会独立保存一份这样的Pattern缓存，因此无需对其访问加锁，这样无疑效率会更高。缺陷则是会损失部分内存。所有的这些都可以通过预先的宏定义来进行开关，使用者可以自行决定使用TLS还是Lock，或者不支持多线程。
1 template < typename TPolicy > 2 class TGlobalPatternStorage : 3 public TPatternStorage<TPolicy> 4 { 5 public: 6 static TGlobalPatternStorage* GetStorage() 7 { 8 #if FL_WITH_THREAD_LOCAL 9 struct ManagedStorage 10 { 11 typedef Utility::TScopedLocker<System::CriticalSection> LockerType; 12 13 System::CriticalSection ManagedCS; 14 Utility::TAutoArray<TGlobalPatternStorage*> Storages; 15 16 ~ManagedStorage() 17 { 18 LockerType Locker(ManagedCS); 19 20 for( SIZE_T i=0; i<Storages.GetLength(); ++i ) 21 { 22 delete Storages[i]; 23 } 24 } 25 26 void AddStorage( TGlobalPatternStorage* Storage ) 27 { 28 assert(Storage); 29 30 LockerType Locker(ManagedCS); 31 32 Storages.AddItem(Storage); 33 } 34 }; 35 36 static ManagedStorage StaticManager; 37 38 static FL_THREAD_LOCAL TGlobalPatternStorage* StaticStorage = NULL; 39 40 if( !StaticStorage ) 41 { 42 StaticStorage = new TGlobalPatternStorage(); 43 44 StaticManager.AddStorage(StaticStorage); 45 } 46 47 return StaticStorage; 48 #else 49 static TGlobalPatternStorage StaticStorage; 50 return &StaticStorage; 51 #endif 52 } 53 };
如上所示为项目中使用TLS的代码。
总结
在将这一系列的优化结合起来之后，可以使得FL的整体效率处于较高水平，不低于C库函数，同时还具备其它格式化库不具备的功能，对于代码安全性等各方面的增强，都有帮助。下面是Test.cpp的测试结果，FL代表的是使用FL库的耗时，CL代表的C库的耗时，同时此测试模拟了多线程环境。
Windows Visual Studio 2013 Release下的输出：
0x64 Test20, -10.0050, X , X 0x64 Test20, -10.0050, X , X 1920 FLElapse:0.0762746 1920 CLElapse:0.269722 1636 FLElapse:0.0756153 7732 FLElapse:0.0766446 7956 FLElapse:0.0762051 7956 CLElapse:0.285714 1636 CLElapse:0.288648 7732 CLElapse:0.289193
Mac Xcode Release:
99 Test20, -10.0050, X , X 18446744073709551615 FLElapse:0.0901681 18446744073709551615 CLElapse:0.19329 18446744073709551615 FLElapse:0.147378 18446744073709551615 FLElapse:0.150375 18446744073709551615 FLElapse:0.153342 18446744073709551615 CLElapse:0.303508 18446744073709551615 CLElapse:0.308418 18446744073709551615 CLElapse:0.307407
这并非完全的测试，更多的测试需要在实际使用过程中来验证。
