codeboss
/
WsComponentPool
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

update v2

This commit is contained in:
codeboss 2025-09-27 23:07:49 +08:00
parent b1705db60f 8d1184212e
commit f0fdd7708e
6 changed files with 42 additions and 44 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
ECSMemoryPool/ECSMemoryPool.vcxproj
View File

@ -16,6 +16,7 @@
<WindowsTargetPlatformVersion Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'">10.0</WindowsTargetPlatformVersion> <WindowsTargetPlatformVersion Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'">10.0</WindowsTargetPlatformVersion>
<WindowsTargetPlatformVersion Condition="'$(Configuration)|$(Platform)' == 'Release|x64'">10.0</WindowsTargetPlatformVersion> <WindowsTargetPlatformVersion Condition="'$(Configuration)|$(Platform)' == 'Release|x64'">10.0</WindowsTargetPlatformVersion>
<QtMsBuild Condition="'$(QtMsBuild)'=='' OR !Exists('$(QtMsBuild)\qt.targets')">$(MSBuildProjectDirectory)\QtMsBuild</QtMsBuild> <QtMsBuild Condition="'$(QtMsBuild)'=='' OR !Exists('$(QtMsBuild)\qt.targets')">$(MSBuildProjectDirectory)\QtMsBuild</QtMsBuild>
<ProjectName>ECSChunkPool</ProjectName>
</PropertyGroup> </PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" /> <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'" Label="Configuration"> <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'" Label="Configuration">

2
ECSMemoryPool/ecs_memorypool.cpp
View File

@ -5,7 +5,7 @@ ECSMemoryPool::ECSMemoryPool()
} }
ChunkAccessIndex::ChunkAccessIndex(ElementControlBlock* ecb, uint64_t chunk_type_code) ChunkAccessIndex::ChunkAccessIndex(ElementControlBlock* ecb, uint64_t chunk_type_code)
:_element_bind(MemoryElement(ecb)), _chunk_type_code(chunk_type_code) :_element_bind(MemoryChunk(ecb)), _chunk_type_code(chunk_type_code)
{ {
} }

26
ECSMemoryPool/ecs_memorypool.h
View File

@ -19,17 +19,17 @@ concept CompenentType = requires(T t, T other, const QJsonObject & in, QJsonObje
/// 组件引用符号 /// 组件引用符号
/// </summary> /// </summary>
/// <typeparam name="T"></typeparam> /// <typeparam name="T"></typeparam>
template<typename T> class ComponentRefer : protected MemoryElement { template<typename T> class ChunkRefer : protected MemoryChunk {
public: public:
ComponentRefer(ElementControlBlock* data) : MemoryElement(data) { referAdd(); } ChunkRefer(ElementControlBlock* data) : MemoryChunk(data) { referAdd(); }
ComponentRefer(const ComponentRefer<T>& other) :MemoryElement(other.data_ptr) { referAdd(); } ChunkRefer(const ChunkRefer<T> &other) :MemoryChunk(other.data_ptr) { referAdd(); }
virtual ~ComponentRefer() { referSub(); } virtual ~ChunkRefer() { referSub(); }
T* dataLock() { T* dataLock() {
return (T*)(MemoryElement::dataLock()); return (T*)(MemoryChunk::dataLock());
} }
void unlock() { void unlock() {
MemoryElement::release(); MemoryChunk::release();
} }
}; };
@ -37,7 +37,7 @@ public:
class ECSMEMORYPOOL_EXPORT ChunkAccessIndex { class ECSMEMORYPOOL_EXPORT ChunkAccessIndex {
private: private:
MemoryElement _element_bind; MemoryChunk _element_bind;
uint64_t _chunk_type_code; uint64_t _chunk_type_code;
std::map<uint64_t, std::pair<uint16_t, uint16_t>> _member_offset; std::map<uint64_t, std::pair<uint16_t, uint16_t>> _member_offset;
@ -93,7 +93,7 @@ public:
/// </summary> /// </summary>
/// <typeparam name="T"></typeparam> /// <typeparam name="T"></typeparam>
/// <returns></returns> /// <returns></returns>
template<CompenentType T> ComponentRefer<T> generate() { template<CompenentType T> ChunkRefer<T> generate() {
std::lock_guard<std::mutex> lockx(_pool_protected_); std::lock_guard<std::mutex> lockx(_pool_protected_);
auto type_code = T::typeCode(); auto type_code = T::typeCode();
@ -103,13 +103,13 @@ public:
// 迭代内存页集合 // 迭代内存页集合
for (auto page_ptr : page_list) { for (auto page_ptr : page_list) {
auto max_element_cnt = page_ptr->maxSliceCount(); auto max_element_cnt = page_ptr->maxCapacity();
auto active_cnt = page_ptr->getActiveCount(); auto active_cnt = page_ptr->getActiveCount();
// 初级校核可用数量 // 初级校核可用数量
if (active_cnt < max_element_cnt) { if (active_cnt < max_element_cnt) {
// 逐个查找数据元素 // 逐个查找数据元素
for (auto eidx = 0; eidx < max_element_cnt; eidx++) { for (auto eidx = 0; eidx < max_element_cnt; eidx++) {
auto slice_ptr = page_ptr->getSlicePtr(eidx); auto slice_ptr = page_ptr->getChunkPtr(eidx);
// 访问排他 // 访问排他
slice_ptr->page_refer->lock(); slice_ptr->page_refer->lock();
// 裁决元素可用性 // 裁决元素可用性
@ -130,15 +130,15 @@ public:
} }
{ {
// 生成新的内存页 // 生成新的内存页
auto new_page = new MemoryPage(MemoryElement::rawSize(T::typeSize()), type_code); auto new_page = new MemoryPage(MemoryChunk::rawSize(T::typeSize()), type_code);
_storage_pages.insert(type_code, new_page); _storage_pages.insert(type_code, new_page);
refer_ptr = new_page->getSlicePtr(0); refer_ptr = new_page->getChunkPtr(0);
refer_ptr->page_refer->getActiveCount(1); refer_ptr->page_refer->getActiveCount(1);
refer_ptr->refer_count++; refer_ptr->refer_count++;
} }
exists_reuse: exists_reuse:
ComponentRefer<T> temp_inst(refer_ptr); ChunkRefer<T> temp_inst(refer_ptr);
auto data_pointer = temp_inst.dataLock(); auto data_pointer = temp_inst.dataLock();
refer_ptr->refer_count--; refer_ptr->refer_count--;
auto dpair = _basic_component_memory_example[T::typeCode()]; auto dpair = _basic_component_memory_example[T::typeCode()];

40
ECSMemoryPool/memory_pages.cpp
View File

@ -7,9 +7,9 @@ MemoryPage::MemoryPage(uint16_t element_size, uint64_t typecode)
pcb.typecode_of_element = typecode; pcb.typecode_of_element = typecode;
} }
uint16_t MemoryPage::dataSliceSize() const uint16_t MemoryPage::chunkSize() const
{ {
return pcb.byte_count_per_element - MemoryElement::data_buffer_offset; return pcb.byte_count_per_element - MemoryChunk::data_buffer_offset;
} }
uint16_t MemoryPage::getActiveCount(uint16_t inc) const uint16_t MemoryPage::getActiveCount(uint16_t inc) const
@ -39,9 +39,9 @@ std::pair<uint64_t, uint32_t> MemoryPage::getRecords() const {
return std::make_pair(pcb.curr_access_usec, pcb.acc_count_per_cycle); return std::make_pair(pcb.curr_access_usec, pcb.acc_count_per_cycle);
} }
ElementControlBlock* MemoryPage::getSlicePtr(int index) { ElementControlBlock* MemoryPage::getChunkPtr(int index) {
auto member_cnt = maxSliceCount(); auto member_cnt = maxCapacity();
auto element_size = sliceRawSize(); auto element_size = chunkRawSize();
ElementControlBlock* element_ptr = nullptr; ElementControlBlock* element_ptr = nullptr;
if (index >= 0 && index < member_cnt) { if (index >= 0 && index < member_cnt) {
@ -79,28 +79,28 @@ uint64_t MemoryPage::elementTypeCode() const
return pcb.typecode_of_element; return pcb.typecode_of_element;
} }
uint16_t MemoryPage::sliceRawSize() const { uint16_t MemoryPage::chunkRawSize() const {
auto data_ptr = const_cast<MemoryPage*>(this); auto data_ptr = const_cast<MemoryPage*>(this);
std::lock_guard<std::mutex> g(data_ptr->pcb.access_protected); std::lock_guard<std::mutex> g(data_ptr->pcb.access_protected);
return pcb.byte_count_per_element; return pcb.byte_count_per_element;
} }
uint16_t MemoryPage::maxSliceCount() const { uint16_t MemoryPage::maxCapacity() const {
uint16_t cnt = sizeof(data_buffer); uint16_t cnt = sizeof(data_buffer);
return cnt / this->sliceRawSize(); return cnt / this->chunkRawSize();
} }
// element ================================================================= // element =================================================================
const uint32_t MemoryElement::data_buffer_offset = MemoryElement::validOffset(); const uint32_t MemoryChunk::data_buffer_offset = MemoryChunk::validOffset();
uint32_t MemoryElement::validOffset() uint32_t MemoryChunk::validOffset()
{ {
uint32_t remains = sizeof(ElementControlBlock) % 16; uint32_t remains = sizeof(ElementControlBlock) % 16;
uint32_t times = sizeof(ElementControlBlock) / 16; uint32_t times = sizeof(ElementControlBlock) / 16;
return (remains ? times + 1 : times) * 16; return (remains ? times + 1 : times) * 16;
} }
uint32_t MemoryElement::rawSize(uint32_t data_type_size) uint32_t MemoryChunk::rawSize(uint32_t data_type_size)
{ {
uint32_t minimal_size = validOffset() + data_type_size; uint32_t minimal_size = validOffset() + data_type_size;
auto remains = minimal_size % 16; auto remains = minimal_size % 16;
@ -108,21 +108,21 @@ uint32_t MemoryElement::rawSize(uint32_t data_type_size)
return (remains ? times + 1 : times) * 16; return (remains ? times + 1 : times) * 16;
} }
MemoryElement::MemoryElement(ElementControlBlock* access_bind) MemoryChunk::MemoryChunk(ElementControlBlock* access_bind)
: data_ptr((ElementControlBlock*)access_bind) {} : data_ptr((ElementControlBlock*)access_bind) {}
uint16_t MemoryElement::typeSize() const uint16_t MemoryChunk::typeSize() const
{ {
auto page_ptr = data_ptr->page_refer; auto page_ptr = data_ptr->page_refer;
return page_ptr->sliceRawSize(); return page_ptr->chunkRawSize();
} }
void MemoryElement::accessUpdate(uint64_t time_usec) void MemoryChunk::accessUpdate(uint64_t time_usec)
{ {
data_ptr->page_refer->accessRecord(time_usec); data_ptr->page_refer->accessRecord(time_usec);
} }
bool MemoryElement::isActived(ElementControlBlock* refer) bool MemoryChunk::isActived(ElementControlBlock* refer)
{ {
refer->page_refer->lock(); refer->page_refer->lock();
auto mark = refer->refer_count; auto mark = refer->refer_count;
@ -130,27 +130,27 @@ bool MemoryElement::isActived(ElementControlBlock* refer)
return mark; return mark;
} }
void MemoryElement::referAdd() void MemoryChunk::referAdd()
{ {
data_ptr->page_refer->lock(); data_ptr->page_refer->lock();
data_ptr->refer_count++; data_ptr->refer_count++;
data_ptr->page_refer->release(); data_ptr->page_refer->release();
} }
void MemoryElement::referSub() void MemoryChunk::referSub()
{ {
data_ptr->page_refer->lock(); data_ptr->page_refer->lock();
data_ptr->refer_count--; data_ptr->refer_count--;
data_ptr->page_refer->release(); data_ptr->page_refer->release();
} }
unsigned char* MemoryElement::dataLock() unsigned char* MemoryChunk::dataLock()
{ {
data_ptr->page_refer->lock(); data_ptr->page_refer->lock();
return ((unsigned char*)data_ptr) + data_buffer_offset; return ((unsigned char*)data_ptr) + data_buffer_offset;
} }
void MemoryElement::release() void MemoryChunk::release()
{ {
data_ptr->page_refer->release(); data_ptr->page_refer->release();
} }

15
ECSMemoryPool/memory_pages.h
View File

@ -55,7 +55,7 @@ public:
/// 内存存储的数据元素的尺寸 /// 内存存储的数据元素的尺寸
/// </summary> /// </summary>
/// <returns></returns> /// <returns></returns>
uint16_t dataSliceSize() const; uint16_t chunkSize() const;
/// <summary> /// <summary>
/// 获取当前活跃元素数量 /// 获取当前活跃元素数量
@ -95,7 +95,7 @@ public:
/// <param name="index">元素索引</param> /// <param name="index">元素索引</param>
/// <param name="active_set">是否设置</param> /// <param name="active_set">是否设置</param>
/// <returns>数据指针</returns> /// <returns>数据指针</returns>
ElementControlBlock* getSlicePtr(int index); ElementControlBlock* getChunkPtr(int index);
/// <summary> /// <summary>
/// 元素类型码 /// 元素类型码
/// </summary> /// </summary>
@ -105,18 +105,18 @@ public:
/// 获取单个元素尺寸 /// 获取单个元素尺寸
/// </summary> /// </summary>
/// <returns>字节数量</returns> /// <returns>字节数量</returns>
uint16_t sliceRawSize() const; uint16_t chunkRawSize() const;
/// <summary> /// <summary>
/// 获取元素数量 /// 获取元素数量
/// </summary> /// </summary>
/// <returns></returns> /// <returns></returns>
uint16_t maxSliceCount() const; uint16_t maxCapacity() const;
}; };
/// <summary> /// <summary>
/// 内存元素访问接口 /// 内存元素访问接口
/// </summary> /// </summary>
class ECSMEMORYPOOL_EXPORT MemoryElement { class ECSMEMORYPOOL_EXPORT MemoryChunk {
protected: protected:
ElementControlBlock* const data_ptr; ElementControlBlock* const data_ptr;
@ -134,7 +134,7 @@ public:
/// 构建内存元素访问接口 /// 构建内存元素访问接口
/// </summary> /// </summary>
/// <param name="access_bind"></param> /// <param name="access_bind"></param>
MemoryElement(ElementControlBlock* access_bind); MemoryChunk(ElementControlBlock* access_bind);
/// <summary> /// <summary>
/// 提取关联元素尺寸 /// 提取关联元素尺寸
@ -147,16 +147,13 @@ public:
/// </summary> /// </summary>
/// <param name="time_usec"></param> /// <param name="time_usec"></param>
void accessUpdate(uint64_t time_usec); void accessUpdate(uint64_t time_usec);
/// <summary> /// <summary>
/// 设置数据活跃状态 /// 设置数据活跃状态
/// </summary> /// </summary>
/// <param name="ste"></param>
void referAdd(); void referAdd();
/// <summary> /// <summary>
/// 设置数据活跃状态 /// 设置数据活跃状态
/// </summary> /// </summary>
/// <param name="ste"></param>
void referSub(); void referSub();
/// <summary> /// <summary>

2
QtConsoleApplication1/QtConsoleApplication1.vcxproj
View File

@ -70,7 +70,7 @@
<LanguageStandard>stdcpp20</LanguageStandard> <LanguageStandard>stdcpp20</LanguageStandard>
</ClCompile> </ClCompile>
<Link> <Link>
<AdditionalDependencies>ECSMemoryPool.lib;%(AdditionalDependencies)</AdditionalDependencies> <AdditionalDependencies>ECSChunkPool.lib;%(AdditionalDependencies)</AdditionalDependencies>
</Link> </Link>
</ItemDefinitionGroup> </ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'" Label="Configuration"> <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'" Label="Configuration">