131 lines
3.2 KiB
C++
131 lines
3.2 KiB
C++
#include "memory_pages.h"
|
|
|
|
MemoryPage::MemoryPage(uint16_t element_size, uint64_t typecode)
|
|
{
|
|
pcb.byte_count_per_element = element_size;
|
|
pcb.total_buffer_size = sizeof(data_buffer);
|
|
pcb.typecode_of_element = typecode;
|
|
}
|
|
|
|
void MemoryPage::accessRecord(uint64_t timepoint_usec) {
|
|
std::lock_guard<std::mutex> g(pcb.access_protected);
|
|
pcb.curr_access_usec = timepoint_usec;
|
|
pcb.acc_count_per_cycle++;
|
|
}
|
|
|
|
uint32_t MemoryPage::timesClear() {
|
|
std::lock_guard<std::mutex> g(pcb.access_protected);
|
|
auto value = pcb.acc_count_per_cycle;
|
|
pcb.acc_count_per_cycle = 0;
|
|
return value;
|
|
}
|
|
|
|
std::pair<uint64_t, uint32_t> MemoryPage::getRecords() const {
|
|
auto data_ptr = const_cast<MemoryPage*>(this);
|
|
std::lock_guard<std::mutex> g(data_ptr->pcb.access_protected);
|
|
return std::make_pair(pcb.curr_access_usec, pcb.acc_count_per_cycle);
|
|
}
|
|
|
|
char* MemoryPage::getElementPtr(int index) {
|
|
auto member_cnt = elementCount();
|
|
auto element_size = elementSize();
|
|
|
|
char* element_ptr = nullptr;
|
|
if (index >= 0 && index < member_cnt) {
|
|
element_ptr = data_buffer + index * element_size;
|
|
}
|
|
else if (index < 0 && index >= -member_cnt) {
|
|
element_ptr = 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;
|
|
}
|
|
release();
|
|
return element_ptr;
|
|
}
|
|
|
|
void MemoryPage::lock()
|
|
{
|
|
pcb.access_protected.lock();
|
|
}
|
|
|
|
void MemoryPage::release() {
|
|
#pragma warning(push)
|
|
#pragma warning(disable : 26110)
|
|
pcb.access_protected.unlock();
|
|
#pragma warning(pop)
|
|
}
|
|
|
|
uint64_t MemoryPage::elementTypeCode() const
|
|
{
|
|
auto data_ptr = const_cast<MemoryPage*>(this);
|
|
std::lock_guard<std::mutex> g(data_ptr->pcb.access_protected);
|
|
return pcb.typecode_of_element;
|
|
}
|
|
|
|
uint16_t MemoryPage::elementSize() const {
|
|
auto data_ptr = const_cast<MemoryPage*>(this);
|
|
std::lock_guard<std::mutex> g(data_ptr->pcb.access_protected);
|
|
return pcb.byte_count_per_element;
|
|
}
|
|
|
|
uint16_t MemoryPage::elementCount() const {
|
|
uint16_t cnt = sizeof(data_buffer);
|
|
return cnt / this->elementSize();
|
|
}
|
|
|
|
uint32_t MemoryElement::validOffset()
|
|
{
|
|
uint32_t remains = sizeof(ElementControlBlock) % 8;
|
|
uint32_t times = sizeof(ElementControlBlock) / 8;
|
|
return (remains ? times + 1 : times) * 8;
|
|
}
|
|
|
|
uint32_t MemoryElement::rawSize(uint32_t data_type_size)
|
|
{
|
|
uint32_t minimal_size = validOffset() + data_type_size;
|
|
auto remains = minimal_size % 16;
|
|
auto times = minimal_size / 16;
|
|
return (remains ? times + 1 : times) * 16;
|
|
}
|
|
|
|
MemoryElement::MemoryElement(char* access_bind)
|
|
: data_ptr((ElementControlBlock*)access_bind) {
|
|
buffer_offset = validOffset();
|
|
}
|
|
|
|
void MemoryElement::accessRecUpdate(uint64_t time_usec)
|
|
{
|
|
data_ptr->page_refer->accessRecord(time_usec);
|
|
}
|
|
|
|
uint8_t MemoryElement::isActived() const
|
|
{
|
|
data_ptr->page_refer->lock();
|
|
auto mark = data_ptr->active_mark;
|
|
data_ptr->page_refer->release();
|
|
return mark;
|
|
}
|
|
|
|
void MemoryElement::setActive(uint8_t ste)
|
|
{
|
|
data_ptr->page_refer->lock();
|
|
data_ptr->active_mark = ste;
|
|
data_ptr->page_refer->release();
|
|
}
|
|
|
|
char* MemoryElement::dataLock()
|
|
{
|
|
data_ptr->page_refer->lock();
|
|
return ((char*)data_ptr) + buffer_offset;
|
|
}
|
|
|
|
void MemoryElement::release()
|
|
{
|
|
data_ptr->page_refer->release();
|
|
}
|