### 动态分区存储管理的实现 动态分区存储管理的核心在于模拟内存分配和回收的过程。以下是基于最优适应算法（Best Fit Algorithm）的一个简单实现： #### 实现代码 ```python class MemoryManager: def __init__(self, total_memory_size): self.total_memory_size = total_memory_size self.memory_blocks = [{'start': 0, 'size': total_memory_size, 'status': 'free'}] def allocate(self, process_name, size_required): best_fit_index = -1 min_waste_space = float('inf') # 查找最适合的空闲块 for i, block in enumerate(self.memory_blocks): if block['status'] == 'free' and block['size'] >= size_required: waste_space = block['size'] - size_required if waste_space < min_waste_space: min_waste_space = waste_space best_fit_index = i if best_fit_index != -1: current_block = self.memory_blocks[best_fit_index] # 如果有剩余空间，则分割成两个部分 if current_block['size'] > size_required: new_free_block = { 'start': current_block['start'] + size_required, 'size': current_block['size'] - size_required, 'status': 'free' } allocated_block = { 'start': current_block['start'], 'size': size_required, 'status': 'allocated', 'process_name': process_name } self.memory_blocks.pop(best_fit_index) self.memory_blocks.insert(best_fit_index, new_free_block) self.memory_blocks.insert(best_fit_index, allocated_block) else: # 完全占用当前块 current_block['status'] = 'allocated' current_block['process_name'] = process_name return f"Process {process_name} successfully allocated." else: return "Memory allocation failed." def free(self, process_name): for i, block in enumerate(self.memory_blocks): if block['status'] == 'allocated' and block.get('process_name') == process_name: block['status'] = 'free' del block['process_name'] break # 合并相邻的空闲块 self._merge_adjacent_free_blocks() def _merge_adjacent_free_blocks(self): """合并相邻的空闲块""" sorted_blocks = sorted(self.memory_blocks, key=lambda x: x['start']) merged_blocks = [] prev_block = None for block in sorted_blocks: if not prev_block or block['status'] != 'free' or (prev_block['status'] != 'free'): merged_blocks.append(block) prev_block = block elif block['start'] == prev_block['start'] + prev_block['size']: prev_block['size'] += block['size'] else: merged_blocks.append(block) prev_block = block self.memory_blocks = merged_blocks def display_memory_status(self): print("\nCurrent memory status:") for idx, block in enumerate(sorted(self.memory_blocks, key=lambda x: x['start'])): print(f"{idx}: Start={block['start']} Size={block['size']} Status={block['status']}", end="") if block.get('process_name'): print(f" Process Name={block['process_name']}") else: print() # 测试动态分区存储管理 if __name__ == "__main__": manager = MemoryManager(100) # 初始化总内存大小为100单位 print(manager.allocate("P1", 20)) # 分配给进程 P1 大小为20的空间 print(manager.allocate("P2", 30)) manager.display_memory_status() # 显示当前内存状态 manager.free("P1") # 回收 P1 的资源 manager.display_memory_status() # 再次显示内存状态 ``` --- ### 动态分页存储管理的实现 动态分页存储管理的关键是对页面表进行维护，记录每一页的状态以及对应的物理帧号。 #### 实现代码 ```python class PagingManager: def __init__(self, num_pages, num_frames): self.num_pages = num_pages self.num_frames = num_frames self.page_table = {i: {'frame': None, 'valid': False} for i in range(num_pages)} self.frames = [None] * num_frames # 物理帧数组初始化为空 def allocate_page(self, page_number): if page_number >= self.num_pages: return "Invalid page number" if self.page_table[page_number]['valid']: # 页面已存在 return f"Page {page_number} is already loaded into frame {self.page_table[page_number]['frame']}" # 寻找可用的物理帧 available_frame = next((i for i, val in enumerate(self.frames) if val is None), None) if available_frame is not None: self.frames[available_frame] = page_number self.page_table[page_number]['frame'] = available_frame self.page_table[page_number]['valid'] = True return f"Page {page_number} has been loaded into Frame {available_frame}." else: return "No frames are currently available" def deallocate_page(self, page_number): if page_number >= self.num_pages: return "Invalid page number" if not self.page_table[page_number]['valid']: # 页面未加载到任何帧中 return f"Page {page_number} was never loaded." frame_to_deallocate = self.page_table[page_number]['frame'] self.frames[frame_to_deallocate] = None self.page_table[page_number]['frame'] = None self.page_table[page_number]['valid'] = False return f"Frame {frame_to_deallocate} has been freed from Page {page_number}" def show_page_table(self): print("\nCurrent Page Table:") for page_num, details in self.page_table.items(): print(f"Page {page_num}: Frame={details['frame']} Valid={'Yes' if details['valid'] else 'No'}") # 测试动态分页存储管理 if __name__ == "__main__": paging_manager = PagingManager(8, 4) # 总共8页，4个物理帧 print(paging_manager.allocate_page(0)) # 加载第0页 print(paging_manager.allocate_page(1)) # 加载第1页 paging_manager.show_page_table() # 显示当前页表 print(paging_manager.deallocate_page(0)) # 卸载第0页 paging_manager.show_page_table() # 再次显示页表 ``` 上述两段代码分别实现了动态分区存储管理和动态分页存储管理的功能[^1][^2]。通过这些代码可以更好地理解两种存储管理机制的工作原理及其操作流程[^3]。