行データ管理クラスでメモリプールを使う事でメモリ確保と解放処理を高速化

sakura/sakura.vcxproj

@@ -430,6 +430,7 @@
     <ClInclude Include="..\sakura_core\macro\CWSHManager.h" />
     <ClInclude Include="..\sakura_core\mem\CMemory.h" />
     <ClInclude Include="..\sakura_core\mem\CMemoryIterator.h" />
+    <ClInclude Include="..\sakura_core\mem\CMemPool.h" />
     <ClInclude Include="..\sakura_core\mem\CNative.h" />
     <ClInclude Include="..\sakura_core\mem\CNativeA.h" />
     <ClInclude Include="..\sakura_core\mem\CNativeT.h" />

sakura/sakura.vcxproj.filters

@@ -1088,6 +1088,9 @@
     <ClInclude Include="..\sakura_core\recent\CRecentExcludeFolder.h">
       <Filter>Cpp Source Files\recent</Filter>
     </ClInclude>
+    <ClInclude Include="..\sakura_core\mem\CMemPool.h">
+      <Filter>Cpp Source Files\mem</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <None Include="..\sakura_core\Funccode_x.hsrc">

sakura_core/doc/logic/CDocLineMgr.cpp

@@ -68,15 +68,15 @@ CDocLineMgr::~CDocLineMgr()
 //! pPosの直前に新しい行を挿入
 CDocLine* CDocLineMgr::InsertNewLine(CDocLine* pPos)
 {
-	CDocLine* pcDocLineNew = new CDocLine;
+	CDocLine* pcDocLineNew = m_memPool.Construct();
 	_InsertBeforePos(pcDocLineNew,pPos);
 	return pcDocLineNew;
 }
 
 //! 最下部に新しい行を挿入
 CDocLine* CDocLineMgr::AddNewLine()
 {
-	CDocLine* pcDocLineNew = new CDocLine;
+	CDocLine* pcDocLineNew = m_memPool.Construct();
 	_PushBottom(pcDocLineNew);
 	return pcDocLineNew;
 }
@@ -87,7 +87,7 @@ void CDocLineMgr::DeleteAllLine()
 	CDocLine* pDocLine = m_pDocLineTop;
 	while( pDocLine ){
 		CDocLine* pDocLineNext = pDocLine->GetNextLine();
-		delete pDocLine;
+		m_memPool.Destruct(pDocLine);
 		pDocLine = pDocLineNext;
 	}
 	_Init();
@@ -118,7 +118,7 @@ void CDocLineMgr::DeleteLine( CDocLine* pcDocLineDel )
 	}
 
 	//データ削除
-	delete pcDocLineDel;
+	m_memPool.Destruct(pcDocLineDel);
 
 	//行数減算
 	m_nLines--;

sakura_core/doc/logic/CDocLineMgr.h

@@ -25,8 +25,9 @@
 #include "basis/SakuraBasis.h"
 #include "util/design_template.h"
 #include "COpe.h"
+#include "CDocLine.h"
+#include "mem/CMemPool.h"
 
-class CDocLine; // 2002/2/10 aroka
 class CBregexp; // 2002/2/10 aroka
 
 struct DocLineReplaceArg {
@@ -89,6 +90,7 @@ class CDocLineMgr{
 	CDocLine*	m_pDocLineTop;		//!< 最初の行
 	CDocLine*	m_pDocLineBot;		//!< 最後の行(※1行しかない場合はm_pDocLineTopと等しくなる)
 	CLogicInt	m_nLines;			//!< 全行数
+	CMemPool<CDocLine> m_memPool;
 
 public:
 	//$$ kobake注: 以下、絶対に切り離したい（最低切り離せなくても、変数の意味をコメントで明確に記すべき）変数群

sakura_core/mem/CMemPool.h

@@ -0,0 +1,142 @@
+/*
+	Copyright (C) 2018-2019 Sakura Editor Organization
+
+	This software is provided 'as-is', without any express or implied
+	warranty. In no event will the authors be held liable for any damages
+	arising from the use of this software.
+
+	Permission is granted to anyone to use this software for any purpose,
+	including commercial applications, and to alter it and redistribute it
+	freely, subject to the following restrictions:
+
+		1. The origin of this software must not be misrepresented;
+		   you must not claim that you wrote the original software.
+		   If you use this software in a product, an acknowledgment
+		   in the product documentation would be appreciated but is
+		   not required.
+
+		2. Altered source versions must be plainly marked as such,
+		   and must not be misrepresented as being the original software.
+
+		3. This notice may not be removed or altered from any source
+		   distribution.
+*/
+
+#ifndef SAKURA_CMEMPOOL_H_
+#define SAKURA_CMEMPOOL_H_
+
+#include <memory>
+#include "util/design_template.h"
+
+// T : 要素型
+// BlockSize : ブロックの大きさのバイト数
+template <typename T, size_t BlockSize = 4096>
+class CMemPool final
+{
+public:
+	DISALLOW_COPY_AND_ASSIGN(CMemPool);
+
+	CMemPool()
+	{
+		// 始めのブロックをメモリ確保
+		AllocateBlock();
+	}
+
+	~CMemPool()
+	{
+		// メモリ確保した領域の連結リストを辿って全てのブロック分のメモリ解放
+		Block* curr = m_currentBlock;
+		while (curr) {
+			Block* next = curr->next;
+			operator delete(curr);
+			curr = next;
+		}
+	}
+
+	// 要素構築、引数は要素型のコンストラクタ引数
+	template <typename... Args>
+	T* Construct(Args&&... args)
+	{
+		T* p = Allocate();
+		new (p) T(std::forward<Args>(args)...);
+		return p;
+	}
+
+	// 要素破棄、引数は Construct が返したポインタ
+	void Destruct(T* p)
+	{
+		if (p) {
+			p->~T();
+			Free(p);
+		}
+	}
+
+private:
+
+	union Node {
+		~Node() {}
+		T element;	// 要素型
+		Node* next; // 解放後の未割当領域の場合は次の未割当領域に繋がる
+	};
+
+	union Block {
+		~Block() {}
+		struct {
+			Block* next;
+			Node nodes[1];
+		};
+		uint8_t padding[BlockSize];
+	};
+
+	// 要素のメモリ確保処理、要素の領域のポインタを返す
+	T* Allocate()
+	{
+		// メモリ確保時には未割当領域から使用していく
+		if (m_unassignedNode) {
+			T* ret = &m_unassignedNode->element;
+			m_unassignedNode = m_unassignedNode->next;
+			return ret;
+		}
+		else {
+			// 未割当領域が無い場合は、ブロックの中のNode領域を使用する
+			if (reinterpret_cast<void*>(m_currentNode + 1) >= reinterpret_cast<void*>(m_currentBlock + 1)) {
+				// 現在のブロックに新規に割り当てるNode分の領域が残っていない場合は新規にブロックを確保
+				AllocateBlock();
+			}
+			T* ret = &m_currentNode->element;
+			++m_currentNode;
+			return ret;
+		}
+	}
+
+	// メモリ解放処理、要素の領域のポインタを受け取る
+	// Allocate メソッドで返したポインタを渡す事
+	void Free(T* p)
+	{
+		if (p) {
+			// メモリ解放した領域を未割当領域として自己参照共用体の片方向連結リストで繋げる
+			// 次回のメモリ確保時にその領域を再利用する
+			Node* next = m_unassignedNode;
+			m_unassignedNode = reinterpret_cast<Node*>(p);
+			m_unassignedNode->next = next;
+		}
+	}
+
+	// 呼び出しの度にメモリの動的確保を細かく行う事を避ける為に、一括でブロック領域を確保
+	void AllocateBlock()
+	{
+		Block* next = m_currentBlock;
+		// 以前に作成したブロックに連結する
+		m_currentBlock = reinterpret_cast<Block*>(operator new(sizeof(Block)));
+		m_currentBlock->next = next;
+
+		// 新規に作成したブロックの先頭のNodeから使用する
+		m_currentNode = &m_currentBlock->nodes[0];
+	}
+
+	Block* m_currentBlock = nullptr; // 現在のブロック
+	Node* m_unassignedNode = nullptr; // 未割当領域の先頭
+	Node* m_currentNode = nullptr; // 現在のブロックの中のNodeを指すポインタ、メモリ確保時に未割当領域が無い場合はここを使う
+};
+
+#endif /* SAKURA_CMEMPOOL_H_ */

tests/unittests/test-cmempool.cpp

@@ -0,0 +1,171 @@
+/*! @file */
+/*
+	Copyright (C) 2018-2019 Sakura Editor Organization
+
+	This software is provided 'as-is', without any express or implied
+	warranty. In no event will the authors be held liable for any damages
+	arising from the use of this software.
+
+	Permission is granted to anyone to use this software for any purpose,
+	including commercial applications, and to alter it and redistribute it
+	freely, subject to the following restrictions:
+
+		1. The origin of this software must not be misrepresented;
+		   you must not claim that you wrote the original software.
+		   If you use this software in a product, an acknowledgment
+		   in the product documentation would be appreciated but is
+		   not required.
+
+		2. Altered source versions must be plainly marked as such,
+		   and must not be misrepresented as being the original software.
+
+		3. This notice may not be removed or altered from any source
+		   distribution.
+*/
+#include <gtest/gtest.h>
+#include "mem/CMemPool.h"
+#include <vector>
+#include <array>
+#include <string>
+#include <type_traits>
+#include <stdint.h>
+#include <Windows.h>
+
+template <typename T>
+class CMemPoolTest : public ::testing::Test{};
+
+// BlockSize テンプレート引数のバリエーション用意
+using test_types = ::testing::Types<
+	std::integral_constant<std::size_t, 1>,
+	std::integral_constant<std::size_t, 2>,
+	std::integral_constant<std::size_t, 3>,
+	std::integral_constant<std::size_t, 4>,
+	std::integral_constant<std::size_t, 8>,
+	std::integral_constant<std::size_t, 16>,
+	std::integral_constant<std::size_t, 32>,
+	std::integral_constant<std::size_t, 64>,
+	std::integral_constant<std::size_t, 128>,
+	std::integral_constant<std::size_t, 256>,
+	std::integral_constant<std::size_t, 512>,
+	std::integral_constant<std::size_t, 1024>, 
+	std::integral_constant<std::size_t, 2048>,
+	std::integral_constant<std::size_t, 4096>,
+	std::integral_constant<std::size_t, 8192>,
+	std::integral_constant<std::size_t, 16384>,
+	std::integral_constant<std::size_t, 32768>,
+	std::integral_constant<std::size_t, 65536>
+>;
+
+TYPED_TEST_CASE(CMemPoolTest, test_types);
+
+// ポインタのアライメントが取れているか確認
+#define is_aligned(POINTER, BYTE_COUNT) (((uintptr_t)(const void *)(POINTER)) % (BYTE_COUNT) == 0)
+
+// デフォルトコンストラクタを指定回数呼び出し
+template <typename T, size_t BlockSize>
+void testPool(size_t sz)
+{
+	CMemPool<T, BlockSize> pool;
+	std::vector<T*> ptrs(sz);
+	// 要素構築
+	for (size_t i=0; i<sz; ++i) {
+		T* p = pool.Construct();
+		ptrs[i] = p;
+		ASSERT_TRUE(p != nullptr); // 領域を確保できたか確認
+		ASSERT_TRUE(is_aligned(p, alignof(T))); // アライメントが取れているか確認
+	}
+	// 要素破棄
+	for (size_t i=0; i<sz; ++i) {
+		pool.Destruct(ptrs[i]);
+	}
+	// 要素破棄後に要素を再度構築
+	for (size_t i=0; i<sz; ++i) {
+		T* p = pool.Construct();
+		ptrs[i] = p;
+		ASSERT_TRUE(p != nullptr); // 領域を確保できたか確認
+		ASSERT_TRUE(is_aligned(p, alignof(T))); // アライメントが取れているか確認
+	}
+	// 再度要素を破棄
+	for (size_t i=0; i<sz; ++i) {
+		pool.Destruct(ptrs[i]);
+	}
+}
+
+// 色々な型やBlockSizeでデフォルトコンストラクタをたくさん呼び出す
+TYPED_TEST(CMemPoolTest, default_constructor)
+{
+	// BlockSize を取得
+	constexpr size_t BlockSize = TypeParam::value;
+
+	// ユーザー定義型の確認用
+	struct TestStruct
+	{
+		int* ptr;
+		char buff[32];
+		long long ll;
+		double f64;
+	};
+
+	/*!
+		色々なケースの確認
+	*/
+	size_t sz = 1;
+	for (size_t i=0; i<10; ++i, sz*=2) {
+		testPool<int8_t, BlockSize>(sz);
+		testPool<int16_t, BlockSize>(sz);
+		testPool<int32_t, BlockSize>(sz);
+		testPool<int64_t, BlockSize>(sz);
+		testPool<float, BlockSize>(sz);
+		testPool<double, BlockSize>(sz);
+		testPool<FILETIME, BlockSize>(sz);
+		testPool<TestStruct, BlockSize>(sz);
+		testPool<std::wstring, BlockSize>(sz);
+	}
+}
+
+// 引数付きコンストラクタ
+TYPED_TEST(CMemPoolTest, parameterized_constructor)
+{
+	constexpr size_t BlockSize = TypeParam::value;
+	CMemPool<std::wstring, BlockSize> pool;
+
+	std::wstring* p0 = nullptr;
+	std::wstring* p1 = nullptr;
+	std::wstring* p2 = nullptr;
+	std::wstring* p3 = nullptr;
+
+	std::wstring s0{L"あいうえお"};
+	std::wstring s1{L"nullptr"};
+	wchar_t c2{'㌍'};
+	size_t len2 = 12345;
+	std::wstring s2(len2, c2);
+	std::wstring s3{L"令和"};
+
+	// 構築と破棄を繰り返して動作するか確認
+	for (size_t i=0; i<8; ++i) {
+		// 要素構築
+		p0 = pool.Construct(s0);
+		p1 = pool.Construct(s1);
+		p2 = pool.Construct(len2, c2);
+		p3 = pool.Construct(s3);
+
+		// 領域を構築できたか確認
+		ASSERT_TRUE(p0 != nullptr);
+		ASSERT_TRUE(p1 != nullptr);
+		ASSERT_TRUE(p2 != nullptr);
+		ASSERT_TRUE(p3 != nullptr);
+
+		// コンストラクタに指定した値と同一か確認
+		ASSERT_TRUE(*p0 == s0);
+		ASSERT_TRUE(*p1 == s1);
+		ASSERT_TRUE(*p2 == s2);
+		ASSERT_TRUE(*p3 == s3);
+
+		// 要素破棄
+		pool.Destruct(p0);
+		pool.Destruct(p1);
+		pool.Destruct(p2);
+		pool.Destruct(p3);
+	}
+}
+