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

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,121 @@
+/*
+	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"
+
+template <typename T, size_t BlockSize = 4096>
+class CMemPool final
+{
+public:
+	DISALLOW_COPY_AND_ASSIGN(CMemPool);
+
+	CMemPool()
+	{
+		AllocateBlock();
+	}
+
+	~CMemPool()
+	{
+		Node* curr = m_currentBlock;
+		while (curr) {
+			Node* next = curr->next;
+			operator delete(reinterpret_cast<void*>(curr));
+			curr = next;
+		}
+	}
+
+	template <typename... Args>
+	T* Construct(Args&&... args)
+	{
+		T* p = Allocate();
+		new (p) T(std::forward<Args>(args)...);
+		return p;
+	}
+
+	void Destruct(T* p)
+	{
+		if (p) {
+			p->~T();
+			Free(p);
+		}
+	}
+
+private:
+	union Node {
+		~Node() {}
+		T element;
+		Node* next;
+	};
+
+	static_assert(BlockSize >= 2 * sizeof(Node), "BlockSize too small.");
+
+	T* Allocate()
+	{
+		if (m_unassignedNode) {
+			T* ret = reinterpret_cast<T*>(m_unassignedNode);
+			m_unassignedNode = m_unassignedNode->next;
+			return ret;
+		}
+		else {
+			Node* border = reinterpret_cast<Node*>(reinterpret_cast<char*>(m_currentBlock) + BlockSize - sizeof(Node) + 1);
+			if (m_currentNode >= border) {
+				AllocateBlock();
+			}
+			return reinterpret_cast<T*>(m_currentNode++);
+		}
+	}
+
+	void Free(T* p)
+	{
+		if (p) {
+			Node* next = m_unassignedNode;
+			m_unassignedNode = reinterpret_cast<Node*>(p);
+			m_unassignedNode->next = next;
+		}
+	}
+
+	void AllocateBlock()
+	{
+		char* buff = reinterpret_cast<char*>(operator new (BlockSize));
+		Node* next = m_currentBlock;
+		m_currentBlock = reinterpret_cast<Node*>(buff);
+		m_currentBlock->next = next;
+
+		void* body = buff + sizeof(Node*);
+		size_t space = BlockSize - sizeof(Node*);
+		body = std::align(alignof(Node), sizeof(Node), body, space);
+		assert(body);
+		m_currentNode = reinterpret_cast<Node*>(body);
+	}
+
+	Node* m_unassignedNode = nullptr;
+	Node* m_currentBlock = nullptr;
+	Node* m_currentNode = nullptr;
+};
+
+#endif /* SAKURA_CMEMPOOL_H_ */

tests/unittests/test-cmempool.cpp

@@ -0,0 +1,118 @@
+/*! @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 <stdint.h>
+#include <Windows.h>
+
+#define is_aligned(POINTER, BYTE_COUNT) (((uintptr_t)(const void *)(POINTER)) % (BYTE_COUNT) == 0)
+
+template <typename T>
+void testPool(size_t sz)
+{
+	CMemPool<T> 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]);
+	}
+}
+
+// デフォルトコンストラクタ
+TEST(CMemPool, default_constructor)
+{
+	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>(sz);
+		testPool<int16_t>(sz);
+		testPool<int32_t>(sz);
+		testPool<int64_t>(sz);
+		testPool<float>(sz);
+		testPool<double>(sz);
+		testPool<FILETIME>(sz);
+		testPool<TestStruct>(sz);
+		testPool<std::wstring>(sz);
+	}
+}
+
+// 引数付きコンストラクタ
+TEST(CMemPool, parameterized_constructor)
+{
+	CMemPool<std::wstring> pool;
+
+	std::wstring* p0 = nullptr;
+	std::wstring* p1 = nullptr;
+	std::wstring* p2 = nullptr;
+	std::wstring* p3 = nullptr;
+
+	p0 = pool.Construct(L"あいうえお");
+	p1 = pool.Construct(L"nullptr");
+	p2 = pool.Construct(12345, '㌍');
+	std::wstring s{L"令和"};
+	p3 = pool.Construct(s);
+
+	ASSERT_TRUE(p0 != nullptr);
+	ASSERT_TRUE(p1 != nullptr);
+	ASSERT_TRUE(p2 != nullptr);
+	ASSERT_TRUE(p3 != nullptr);
+
+	ASSERT_TRUE(p0->size() == 5);
+	ASSERT_TRUE(p1->size() == 7);
+	ASSERT_TRUE(p2->size() == 12345);
+	ASSERT_TRUE(p3->size() == 2);
+	ASSERT_TRUE(*p3 == s);
+
+	pool.Destruct(p0);
+	pool.Destruct(p1);
+	pool.Destruct(p2);
+	pool.Destruct(p3);
+}
+
+// ブロックサイズ
+TEST(CMemPool, BlockSize)
+{
+	CMemPool<std::array<uint8_t, 2048>> pool;
+	CMemPool<std::array<uint8_t, 4096>, 8192> pool2;
+}
+