改进Page和Element控制块结构和周边接口

ECSMemoryPool/memory_pages.cpp

@@ -26,23 +26,22 @@ std::pair<uint64_t, uint32_t> MemoryPage::getRecords() const {
 	return std::make_pair(pcb.curr_access_usec, pcb.acc_count_per_cycle);
 }
 
-char* MemoryPage::getElementPtr(int index) {
+ElementControlBlock* MemoryPage::getElementPtr(int index) {
 	auto member_cnt = elementCount();
 	auto element_size = elementSize();
 
-	char* element_ptr = nullptr;
+	ElementControlBlock* element_ptr = nullptr;
 	if (index >= 0 && index < member_cnt) {
-		element_ptr = data_buffer + index * element_size;
+		element_ptr = (ElementControlBlock*)(data_buffer + index * element_size);
 	}
 	else if (index < 0 && index >= -member_cnt) {
-		element_ptr = data_buffer + (member_cnt + index) * element_size;
+		element_ptr = (ElementControlBlock*)(data_buffer + (member_cnt + index) * element_size);
 	}
 
 	lock();
 	if (element_ptr) {
-		auto data_ptr = (ElementControlBlock*)element_ptr;
-		data_ptr->page_refer = this;
-		data_ptr->element_index = index;
+		element_ptr->page_refer = this;
+		element_ptr->element_index = index;
 	}
 	release();
 	return element_ptr;
@@ -78,11 +77,14 @@ uint16_t MemoryPage::elementCount() const {
 	return cnt / this->elementSize();
 }
 
+// element =================================================================
+const uint32_t MemoryElement::buffer_offset = MemoryElement::validOffset();
+
 uint32_t MemoryElement::validOffset()
 {
-	uint32_t remains = sizeof(ElementControlBlock) % 8;
-	uint32_t times = sizeof(ElementControlBlock) / 8;
-	return (remains ? times + 1 : times) * 8;
+	uint32_t remains = sizeof(ElementControlBlock) % 16;
+	uint32_t times = sizeof(ElementControlBlock) / 16;
+	return (remains ? times + 1 : times) * 16;
 }
 
 uint32_t MemoryElement::rawSize(uint32_t data_type_size)
@@ -93,12 +95,16 @@ uint32_t MemoryElement::rawSize(uint32_t data_type_size)
 	return (remains ? times + 1 : times) * 16;
 }
 
-MemoryElement::MemoryElement(char* access_bind)
-	: data_ptr((ElementControlBlock*)access_bind) {
-	buffer_offset = validOffset();
+MemoryElement::MemoryElement(ElementControlBlock* access_bind)
+	: data_ptr((ElementControlBlock*)access_bind) {}
+
+uint32_t MemoryElement::typeSize() const
+{
+	auto page_ptr = data_ptr->page_refer;
+	return ((PageControlBlock*)page_ptr)->byte_count_per_element - buffer_offset;
 }
 
-void MemoryElement::accessRecUpdate(uint64_t time_usec)
+void MemoryElement::accessUpdate(uint64_t time_usec)
 {
 	data_ptr->page_refer->accessRecord(time_usec);
 }
@@ -118,10 +124,10 @@ void MemoryElement::setActive(uint8_t ste)
 	data_ptr->page_refer->release();
 }
 
-char* MemoryElement::dataLock()
+unsigned char* MemoryElement::dataLock()
 {
 	data_ptr->page_refer->lock();
-	return ((char*)data_ptr) + buffer_offset;
+	return ((unsigned char*)data_ptr) + buffer_offset;
 }
 
 void MemoryElement::release()

ECSMemoryPool/memory_pages.h

@@ -8,31 +8,47 @@ class MemoryPage;
 /// </summary>
 struct PageControlBlock {
 	uint16_t active_entities_count = 0;		// 活跃element数量，决定是否需要卸载
-
 	uint16_t byte_count_per_element = 32;	// 单个element大小，16的倍数
 	uint32_t total_buffer_size = 0;			// 可用数据缓冲区大小
+
 	uint64_t typecode_of_element = 0;		// 元素类型标识码
 
 	uint64_t curr_access_usec = 0;			// 最近访问时间点，lsb：us
+
 	uint32_t acc_count_per_cycle = 0;		// 单周期内累积访问次数
-	uint32_t un_used = 0;
+	uint32_t backup = 0;
 
 	std::mutex access_protected;			// 内存数据访问保护锁
 };
+
+/// <summary>
+/// 元素访问控制块
+/// </summary>
+struct ElementControlBlock {
+	uint8_t		active_mark = 0;			// 活跃标志
+	uint8_t		backup_1 = 0;
+	uint16_t	element_index = 0;			// 本元素在Page中的索引
+
+	MemoryPage* page_refer = nullptr;		// 页面关联指针
+	void* extend_bind = nullptr;		// 绑定控制块内存指针
+};
+
+
+
 /// <summary>
 /// 内存页面16K大小
 /// </summary>
 class MemoryPage {
 private:
 	PageControlBlock pcb;
-	char data_buffer[16 * 1024 - (sizeof(PageControlBlock) / 8 + 1) * 8] = {};
+	unsigned char data_buffer[16 * 1024 - (sizeof(PageControlBlock) / 8 + 1) * 8] = {};
 
 public:
 	/// <summary>
 	/// 构建内存页
 	/// </summary>
-	/// <param name="raw_element_size_16B">原始element尺寸</param>
-	explicit MemoryPage(uint16_t raw_element_size_16B, uint64_t typecode);
+	/// <param name="raw_esize_16B">原始element尺寸</param>
+	explicit MemoryPage(uint16_t raw_esize_16B, uint64_t typecode);
 
 	/// <summary>
 	/// 记录单次访问时间
@@ -65,7 +81,7 @@ public:
 	/// <param name="index">元素索引</param>
 	/// <param name="active_set">是否设置</param>
 	/// <returns>数据指针</returns>
-	char* getElementPtr(int index);
+	ElementControlBlock* getElementPtr(int index);
 	/// <summary>
 	/// 元素类型码
 	/// </summary>
@@ -83,28 +99,13 @@ public:
 	uint16_t elementCount() const;
 };
 
-
-/// <summary>
-/// 元素访问控制块
-/// </summary>
-struct ElementControlBlock {
-	uint8_t		active_mark = 0;			// 活跃标志
-	uint8_t		backup_1 = 0;
-	uint16_t	byte_count = 16;			// 该元素字节长度，16的倍数
-	uint16_t	element_index = 0;			// 本元素在Page中的索引
-	uint16_t	backup_2 = 0;
-	MemoryPage* page_refer = nullptr;		// 页面关联指针
-	void*		extend_bind = nullptr;		// 绑定控制块内存指针
-};
-
-
 /// <summary>
 /// 内存元素访问接口
 /// </summary>
 class MemoryElement {
 private:
 	ElementControlBlock* const data_ptr;
-	uint32_t buffer_offset = 0;
+	static const uint32_t buffer_offset;
 
 public:
 	static uint32_t validOffset();
@@ -114,13 +115,19 @@ public:
 	/// 构建内存元素访问接口
 	/// </summary>
 	/// <param name="access_bind"></param>
-	MemoryElement(char* access_bind);
+	MemoryElement(ElementControlBlock* access_bind);
+
+	/// <summary>
+	/// 提取关联元素尺寸
+	/// </summary>
+	/// <returns></returns>
+	uint32_t typeSize() const;
 
 	/// <summary>
 	/// 更新最终访问时间
 	/// </summary>
 	/// <param name="time_usec"></param>
-	void accessRecUpdate(uint64_t time_usec);
+	void accessUpdate(uint64_t time_usec);
 
 	/// <summary>
 	/// 数据活跃状态
@@ -137,7 +144,7 @@ public:
 	/// 锁定数据，返回数据存储内存指针
 	/// </summary>
 	/// <returns></returns>
-	char* dataLock();
+	unsigned char* dataLock();
 	/// <summary>
 	/// 解锁数据
 	/// </summary>