EIP-7923: 线性、基于页面的内存计费

diff --git a/eth/vm/computation.py b/eth/vm/computation.py
index bf34fbee..db85aee7 100644
--- a/eth/vm/computation.py
+++ b/eth/vm/computation.py
@@ -454,34 +454,40 @@ class BaseComputation(ComputationAPI, Configurable):
         validate_uint256(start_position, title="Memory start position")
         validate_uint256(size, title="Memory size")

-        before_size = ceil32(len(self._memory))
-        after_size = ceil32(start_position + size)
+        before_size = ceil32(len(self._memory))  // 计算内存扩展之前的内存大小
+        after_size = ceil32(start_position + size)  // 计算内存扩展之后的内存大小
+
+        before_cost = memory_gas_cost(before_size)  // 计算内存扩展之前的 gas 成本
+        after_cost = memory_gas_cost(after_size)  // 计算内存扩展之后的 gas 成本
+
+        if self.logger.show_debug2:
+            // 如果启用了调试模式，则记录扩展内存的大小和 gas 成本
+            self.logger.debug2(
+                f"MEMORY: size ({before_size} -> {after_size}) | "
+                f"cost ({before_cost} -> {after_cost})"
+            )
+
+        if size:
+            // 如果 before_cost 小于 after_cost，则计算 gas 费用
+            if before_cost < after_cost:
+                gas_fee = after_cost - before_cost
+                self._gas_meter.consume_gas(  // 从 gas 计量器中扣除 gas 费用
+                    gas_fee,
+                    reason=" ".join(  // 设置 gas 消耗的原因
+                        (
+                            "Expanding memory",
+                            str(before_size),
+                            "->",
+                            str(after_size),
+                        )
+                    ),
+                )

-        before_cost = memory_gas_cost(before_size)
-        after_cost = memory_gas_cost(after_size)
-
-        if self.logger.show_debug2:
-            self.logger.debug2(
-                f"MEMORY: size ({before_size} -> {after_size}) | "
-                f"cost ({before_cost} -> {after_cost})"
-            )
-
-        if size:
-            if before_cost < after_cost:
-                gas_fee = after_cost - before_cost
-                self._gas_meter.consume_gas(
-                    gas_fee,
-                    reason=" ".join(
-                        (
-                            "Expanding memory",
-                            str(before_size),
-                            "->",
-                            str(after_size),
-                        )
-                    ),
-                )
-
-            self._memory.extend(start_position, size)
+            self._memory.extend(start_position, size)  // 扩展内存
         if size == 0:
             return
 
@@ -493,27 +499,32 @@
 
         end = start_position + size
 
-        start_page = start_position >> LOWER_BITS
-        end_page = end >> LOWER_BITS
+        start_page = start_position >> LOWER_BITS  //内存起始位置的页号
+        end_page = end >> LOWER_BITS  // 内存终止为止的页号
 
         for page in range(start_page, end_page + 1):
+            // 遍历所有被访问的页面
             if page not in self._memory.pages:
+                // 如果该页面之前未被访问过
                 if self.transaction_context.num_pages >= TRANSACTION_MAX_PAGES:
+                    // 如果事务分配的页面数大于允许分配的最大值
                     raise VMError("Out Of Memory")
+                    // 则报内存溢出错误
                 self.transaction_context.num_pages += 1
 
-                reason = f"Allocating page {hex(page << LOWER_BITS)}"
+                reason = f"Allocating page {hex(page << LOWER_BITS)}"  // 设置 gas 消耗的原因
                 self._gas_meter.consume_gas(ALLOCATE_PAGE_COST, reason)
+                // 从 gas 计量器中扣除分配页面的 gas 费用
                 self._memory.pages[page] = True
+                // 标记该页面已经被分配

             if page not in self._memory.lru_pages:
+                // 如果该页面没有被 LRU 缓存
                 reason = f"Page {hex(page << LOWER_BITS)} not in LRU pages"
+                // 设置 gas 消耗的原因
                 self._gas_meter.consume_gas(THRASH_PAGE_COST, reason)
+                // 从 gas 计量器中扣除页面交换的 gas 费用
                 # insert into the lru_pages data structure.
-                # it's important to do it here rather than after
-                # the loop, since this could evict a page we haven't
-                # visited yet, increasing the cost.
                 self._memory.lru_pages[page] = True
 

     def memory_write(self, start_position: int, size: int, value: bytes) -> None:
@@ -43,6 +49,7 @@ from eth.exceptions import (
     InsufficientFunds,
     OutOfGas,
     StackDepthLimit,
+     // 定义 VMError 异常
     VMError,
 )
 from eth.vm.computation import (
@@ -73,6 +80,7 @@ class FrontierComputation(BaseComputation):

         state.touch_account(message.storage_address)

+         //从 gas 计量器中扣除 gas 费用，如果gas不足则返回错误
         computation = cls.apply_computation(
             state,
             message,
@@ -89,6 +97,7 @@
         finally:
             # "deallocate" all the pages allocated in the child computation
 
+             // 在子计算完成之后，“释放” 所有子计算中分配的的页面
             # sanity check an invariant:
             allocated_pages = len(computation._memory.pages)
             assert transaction_context.num_pages == num_pages_anchor + allocated pages
diff --git a/eth/vm/logic/memory.py b/eth/vm/logic/memory.py
index 806dbd8b..247b3c74 100644
--- a/eth/vm/logic/memory.py
+++ b/eth/vm/logic/memory.py
@@ -17,11 +17,13 @@ def mload(computation: ComputationAPI) -> None:


 def msize(computation: ComputationAPI) -> None:
+    // 将当前内存大小压入堆栈
     computation.stack_push_int(computation._memory.msize)


 def mcopy(computation: ComputationAPI) -> None:
diff --git a/eth/vm/memory.py b/eth/vm/memory.py
index 2ccfd090..9002b559 100644
--- a/eth/vm/memory.py
+++ b/eth/vm/memory.py
@@ -1,14 +1,16 @@
 import logging

+ //导入 mmap 模块
 import mmap
 
 from eth._utils.numeric import (
     ceil32,
 )
+ // 定义 VMError
 from eth.exceptions import VMError
 from eth.abc import (
     MemoryAPI,
+     //从堆栈中弹出一个项
 )
 from eth.validation import (
     validate_uint256,
@@ -17,100 +19,108 @@ from eth.validation import (
     validate_uint256,
 )

+ // 导入 LRU 缓存类
 from lru import LRU
 

 class Memory(MemoryAPI):
-    __slots__ = ["_bytes"]
+    __slots__ = ("pages", "lru_pages", "msize")  // 定义类的插槽，用于存储页数据，LRU 缓存数据和内存大小
     logger = logging.getLogger("eth.vm.memory.Memory")
 
     def __init__(self) -> None:
-        self._bytes = bytearray()
+        self.memview = mmap.mmap(-1, 2**32, flags=mmap.MAP_PRIVATE | mmap.MAP_ANONYMOUS)  // 创建一个匿名共享内存区域，大小为  2**32 字节
+        self.pages = {}  // 创建一个字典用于存储内存页，键为页号
+        // LRU 缓存，最大容量为 512
+        self.lru_pages = LRU(512)
+        self.msize = 0  // 内存大小，初始化为 0
+
+    // 扩展内存，使其至少可以容纳从 start_position 开始的 size 大小的数据
+    def extend(self, start_position: int, size: int) -> None:
+ // 如果 size 为 0，则直接返回不执行任何操作
+        if size == 0:
+            return
+
+          // 如果 内存起始位置 + size  大于当前内存大小 msize
+        if start_position + size > self.msize:
+ // 则设置新的内存大小 为 向上取整到 32byte
+            self.msize = ceil32(start_position + size)
+ //将数据 value 写入到内存中，从 start_position 位置开始，共写入 size 个字节
+    def write(self, start_position: int, size: int, value: bytes) -> None:
+ // 如果 size 为 0，则直接返回不执行任何操作
+        if size == 0:
+            return
+ // 如果 内存起始位置 + size  大于等于 2**32
+        if start_position + size >= 2**32:
+            // 如果地址超出范围，则抛出异常 VMError
+            raise VMError("Non 32-bit address")
+ //校验 start_position 是一个 uint256 类型的整数
+        validate_uint256(start_position)
+ //校验 size 是一个 uint256 类型的整数
+        validate_uint256(size)
+ // value 是一个字节串
+        validate_is_bytes(value)
+ // value 长度为 size
+        validate_length(value, length=size)
+
+        end_position = start_position + size  // 计算出结束位置
+
+        self.memview[start_position : end_position] = value  // 将 value 写入内存
+
+    // 未使用
+ //从内存中读取数据，从 start_position 开始读取 size 个字节
+    def read(self, start_position: int, size: int) -> memoryview:
+        // 返回一个 memoryview 对象，该对象指向内存中的指定区域
+        return memoryview(self.memview)[start_position : start_position + size]
+
+    // 从内存中读取字节码，从 start_position 开始读取 size 个字节
+    def read_bytes(self, start_position: int, size: int) -> bytes:
+        // 返回一个字节串，包含从内存中读取的数据
+        return bytes(self.memview[start_position : start_position + size])
+ //将内存中的一段区域的数据复制到另一段区域，从 source 复制 length 个字节到 destination
+    def copy(self, destination: int, source: int, length: int) -> None:
+ // 如果 length 为 0，则直接返回不执行任何操作
+        if length == 0:
+            return
+ //校验 destination 是一个 uint256 类型的整数
+        validate_uint256(destination)
+ //校验 source 是一个 uint256 类型的整数
+        validate_uint256(source)
+ //校验 length 是一个 uint256 类型的整数
+        validate_uint256(length)
+
+        buf = memoryview(self.memview)  // 创建一个 memoryview 对象，该对象指向内存中的指定区域
+ // 将内存中的一段区域的数据复制到另一段区域，从 source 复制 length 个字节到 destination
+        buf[destination : destination + length] = buf[source : source + length]
+
+        // 如果 destination, source 加上 length 的最大值 大于内存大小，则抛出异常
+
+ // 如果没有数据需要追加，则直接返回
+
+ // 获取当前内存的大小
+ // 将数据追加到内存中
+	// 如果长度大于等于 2**32
+
+	// 创建一个新的字节数组，长度为 size_to_extend
         new_size = ceil32(start_position + size)
         if new_size <= len(self):
             return

         size_to_extend = new_size - len(self)
-        try:
-            self._bytes.extend(bytearray(size_to_extend))
-        except BufferError:
+ try:
+  // try to extend memory by allocating new pages
+            self.memview.extend(bytearray(size_to_extend))
+        except BufferError:	// 如果扩展内存失败
             # we can't extend the buffer (which might involve relocating it) if a
-            # memoryview (which stores a pointer into the buffer) has been created by
+            //如果无法扩展缓冲区（可能涉及重新定位），原因是由 read() 创建的 memoryview（存储指向缓冲区的指针）尚未释放。
             # read() and not released. Callers of read() will never try to write to the
-            # buffer so we're not missing anything by making a new buffer and forgetting
-            # about the old one. We're keeping too much memory around but this is still
-            # a net savings over having read() return a new bytes() object every time.
-            self._bytes = self._bytes + bytearray(size_to_extend)
+            // read() 的调用者永远不会尝试写入缓冲区，因此我们通过创建一个新缓冲区并忘记旧缓冲区，不会错过任何内容。
+            self.memview = self.memview + bytearray(size_to_extend)  // 将新的字节数组追加到 `self._bytes` 的末尾
 

-    def __len__(self) -> int:
-        return len(self._bytes)
+ //计算并设置新的尺寸, 从 msize 字节扩展到 new_size 字节
+   //返回内存的内存视图
+	//返回当前的内存大小
+    //将 value 数据写入内存，从 start_position 开始，写入 size 大小的数据
+
+    //从内存中读取指定长度的数据
+
+    //将内存拷贝到指定位置
diff --git a/eth/vm/transaction_context.py b/eth/vm/transaction_context.py
index 79b570e9..5943f897 100644
--- a/eth/vm/transaction_context.py
+++ b/eth/vm/transaction_context.py
@@ -36,6 +36,7 @@ class BaseTransactionContext(TransactionContextAPI):
         # post-cancun
         self._blob_versioned_hashes = blob_versioned_hashes or []

+         // 初始化 num_pages 属性，用于统计交易中使用的总页数
         # eip-7923
         self.num_pages = 0