Machine: extend memory-backed to support large/64-bit memory

Signed-off-by: Pavel Pisa <pisa@fel.cvut.cz>

Author: ppisa

src/machine/memory/backend/backend_memory.h

@@ -15,7 +15,7 @@ namespace machine {
 /**
  * Relative index within an instance of backend memory.
  */
-typedef size_t Offset;
+typedef uint64_t Offset;
 
 /**
  * Interface for physical memory or periphery.
@@ -105,8 +105,8 @@ class BackendMemory : public QObject {
      */
     void external_backend_change_notify(
         const BackendMemory *mem_access,
-        uint32_t start_addr,
-        uint32_t last_addr,
+        Offset start_addr,
+        Offset last_addr,
         AccessEffects type) const;
 };
 

src/machine/memory/backend/memory.cpp

@@ -19,14 +19,14 @@ WriteResult
 MemorySection::write(Offset dst_offset, const void *source, size_t size, WriteOptions options) {
     UNUSED(options)
 
-    auto destination = static_cast<size_t>(dst_offset);
-
-    if (destination >= length()) {
+    if (dst_offset >= length()) {
         throw SIMULATOR_EXCEPTION(
             OutOfMemoryAccess, "Trying to write outside of the memory section",
-            QString("Accessing using offset: ") + QString::number(destination));
+            QString("Accessing using offset: ") + QString::number(dst_offset));
     }
 
+    size_t destination = static_cast<size_t>(dst_offset);
+
     // Size the can be read from this section
     const size_t available_size = std::min(destination + size, length()) - destination;
 
@@ -41,16 +41,16 @@ ReadResult
 MemorySection::read(void *destination, Offset src_offset, size_t size, ReadOptions options) const {
     UNUSED(options)
 
-    auto source = static_cast<size_t>(src_offset);
-
-    size = std::min(source + size, length()) - source;
-
-    if (source >= length()) {
+    if (src_offset >= length()) {
         throw SIMULATOR_EXCEPTION(
             OutOfMemoryAccess, "Trying to read outside of the memory section",
-            QString("Accessing using offset: ") + QString::number(source));
+            QString("Accessing using offset: ") + QString::number(src_offset));
     }
 
+    size_t source = static_cast<size_t>(src_offset);
+
+    size = std::min(source + size, length()) - source;
+
     memcpy(destination, &dt[source], size);
 
     return { .n_bytes = size };
@@ -80,10 +80,6 @@ bool MemorySection::operator!=(const MemorySection &ms) const {
 // Settings sanity checks
 static_assert(MEMORY_SECTION_SIZE != 0, "Nonzero memory section size is required.");
 static_assert(MEMORY_TREE_ROW_SIZE != 0, "Nonzero memory tree row size is required.");
-static_assert(
-    ((32 - MEMORY_SECTION_BITS) % MEMORY_TREE_BITS) == 0,
-    "Number of bits in tree row has to be exact division of available number "
-    "of bits.");
 
 /**
  * Generate mask to get memory section index from address.
@@ -96,14 +92,15 @@ static_assert(
  *  ```address & generate_mask(8, 0)```
  */
 constexpr uint64_t generate_mask(size_t section_size, size_t unit_size) {
-    return ((1U << section_size) - 1) << unit_size;
+    return ((1LLU << section_size) - 1) << unit_size;
 }
 
 /**
  * Get index in row for given offset and row number i
  */
 constexpr size_t tree_row_bit_offset(size_t i) {
-    return 32 - MEMORY_TREE_BITS - i * MEMORY_TREE_BITS;
+    return (MEMORY_TREE_BITS * MEMORY_TREE_DEPTH + MEMORY_SECTION_BITS)
+           - MEMORY_TREE_BITS * (i + 1);
 }
 
 /*
@@ -143,7 +140,7 @@ void Memory::reset(const Memory &m) {
     this->mt_root = copy_section_tree(m.get_memory_tree_root(), 0);
 }
 
-MemorySection *Memory::get_section(size_t offset, bool create) const {
+MemorySection *Memory::get_section(Offset offset, bool create) const {
     union MemoryTree *w = this->mt_root;
     size_t row_num;
     // Walk memory tree branch from root to leaf and create new nodes when
@@ -221,7 +218,7 @@ union machine::MemoryTree *Memory::allocate_section_tree() {
     return mt;
 }
 
-void Memory::free_section_tree(union MemoryTree *mt, size_t depth) {
+void Memory::free_section_tree(union MemoryTree *mt, unsigned depth) {
     if (depth < (MEMORY_TREE_DEPTH - 1)) { // Following level is memory tree
         for (size_t i = 0; i < MEMORY_TREE_ROW_SIZE; i++) {
             if (mt[i].subtree != nullptr) {
@@ -239,7 +236,7 @@ void Memory::free_section_tree(union MemoryTree *mt, size_t depth) {
 bool Memory::compare_section_tree(
     const union MemoryTree *mt1,
     const union MemoryTree *mt2,
-    size_t depth) {
+    unsigned depth) {
     if (depth < (MEMORY_TREE_DEPTH - 1)) { // Following level is memory tree
         for (size_t i = 0; i < MEMORY_TREE_ROW_SIZE; i++) {
             if (((mt1[i].subtree == nullptr || mt2[i].subtree == nullptr)
@@ -260,7 +257,7 @@ bool Memory::compare_section_tree(
     return true;
 }
 
-union machine::MemoryTree *Memory::copy_section_tree(const union MemoryTree *mt, size_t depth) {
+union machine::MemoryTree *Memory::copy_section_tree(const union MemoryTree *mt, unsigned depth) {
     union MemoryTree *nmt = allocate_section_tree();
     if (depth < (MEMORY_TREE_DEPTH - 1)) { // Following level is memory tree
         for (size_t i = 0; i < MEMORY_TREE_ROW_SIZE; i++) {

src/machine/memory/backend/memory.h

@@ -45,16 +45,17 @@ class MemorySection final : public BackendMemory {
 //////////////////////////////////////////////////////////////////////////////
 /// Some optimisation options
 // How big memory sections will be in bits (2^8=256 bytes)
-constexpr size_t MEMORY_SECTION_BITS = 8;
+constexpr unsigned MEMORY_SECTION_BITS = 12;
 // How big one row of lookup tree will be in bits (2^4=16)
-constexpr size_t MEMORY_TREE_BITS = 4;
+constexpr unsigned MEMORY_TREE_BITS = 9;
 //////////////////////////////////////////////////////////////////////////////
 // Size of one section
-constexpr size_t MEMORY_SECTION_SIZE = (1u << MEMORY_SECTION_BITS);
+constexpr size_t MEMORY_SECTION_SIZE = (1llu << MEMORY_SECTION_BITS);
 // Size of one memory row
-constexpr size_t MEMORY_TREE_ROW_SIZE = (1u << MEMORY_TREE_BITS);
+constexpr size_t MEMORY_TREE_ROW_SIZE = (1llu << MEMORY_TREE_BITS);
 // Depth of tree
-constexpr size_t MEMORY_TREE_DEPTH = ((32 - MEMORY_SECTION_BITS) / MEMORY_TREE_BITS);
+constexpr unsigned MEMORY_TREE_DEPTH = ((64 - MEMORY_SECTION_BITS
+                            + MEMORY_TREE_BITS - 1) / MEMORY_TREE_BITS);
 
 union MemoryTree {
     union MemoryTree *subtree;
@@ -78,7 +79,7 @@ class Memory final : public BackendMemory {
     void reset(const Memory &);
 
     // returns section containing given address
-    [[nodiscard]] MemorySection *get_section(size_t offset, bool create) const;
+    [[nodiscard]] MemorySection *get_section(Offset offset, bool create) const;
 
     WriteResult
     write(Offset destination, const void *source, size_t size, WriteOptions options) override;
@@ -97,10 +98,10 @@ class Memory final : public BackendMemory {
     union MemoryTree *mt_root;
     uint32_t change_counter = 0;
     static union MemoryTree *allocate_section_tree();
-    static void free_section_tree(union MemoryTree *, size_t depth);
+    static void free_section_tree(union MemoryTree *, unsigned depth);
     static bool
-    compare_section_tree(const union MemoryTree *, const union MemoryTree *, size_t depth);
-    static union MemoryTree *copy_section_tree(const union MemoryTree *, size_t depth);
+    compare_section_tree(const union MemoryTree *, const union MemoryTree *, unsigned depth);
+    static union MemoryTree *copy_section_tree(const union MemoryTree *, unsigned depth);
     [[nodiscard]] uint32_t get_change_counter() const;
 };
 } // namespace machine