first commit

command_interpreter.py

@@ -0,0 +1,251 @@
+import re
+from typing import Dict, Any, Callable
+from process_management import Process, ProcessState
+from resource_management import ResourceType
+from memory_management import MemoryAllocationStrategy
+
+
+class CommandInterpreter:
+    """
+    解释并执行模拟操作系统的命令
+    """
+
+    def __init__(self):
+        # 命令映射
+        self.commands: Dict[str, Callable] = {
+            'ALLOCATE': self.allocate_memory,
+            'REQUEST_RESOURCE': self.request_resource,
+            'RELEASE_RESOURCE': self.release_resource,
+            'CREATE_FILE': self.create_file,
+            'DELETE_FILE': self.delete_file,
+            'READ_FILE': self.read_file,
+            'WRITE_FILE': self.write_file,
+            'DISK_SEEK': self.optimize_disk_seek,
+        }
+
+    def execute_command(self, command: str, process: Process, os_system: Any):
+        """
+        解析并执行给定进程的命令
+
+        :param command: 要执行的命令字符串
+        :param process: 执行命令的进程
+        :param os_system: 操作系统引用
+        """
+        # 将命令分词
+        tokens = command.strip().split()
+
+        if not tokens:
+            return
+
+        # 提取命令和参数
+        cmd = tokens[0].upper()
+        args = tokens[1:]
+
+        # 查找并执行相应的命令
+        if cmd in self.commands:
+            try:
+                self.commands[cmd](process, os_system, *args)
+            except Exception as e:
+                print(f"执行命令 {cmd} 时出错: {e}")
+        else:
+            print(f"未知命令: {cmd}")
+
+    def allocate_memory(self, process: Process, os_system: Any, size: str = None, strategy: str = None):
+        """
+        为进程分配内存
+
+        :param process: 请求内存分配的进程
+        :param os_system: 操作系统引用
+        :param size: 要分配的内存大小
+        :param strategy: 内存分配策略
+        """
+        # 将大小转换为整数
+        try:
+            memory_size = int(size or 1024)  # 如果未指定，默认1KB
+        except ValueError:
+            memory_size = 1024
+
+        # 确定分配策略
+        if strategy:
+            strategy = strategy.lower()
+            allocation_strategies = {
+                'first': MemoryAllocationStrategy.FIRST_FIT,
+                'best': MemoryAllocationStrategy.BEST_FIT,
+                'worst': MemoryAllocationStrategy.WORST_FIT
+            }
+            os_system.memory_manager.allocation_strategy = allocation_strategies.get(
+                strategy,
+                MemoryAllocationStrategy.FIRST_FIT
+            )
+
+        # 分配内存
+        start_address = os_system.memory_manager.allocate_memory(
+            process.pid,
+            memory_size
+        )
+
+        if start_address is not None:
+            print(f"进程 {process.pid} 分配了 {memory_size} 字节，地址为 {start_address}")
+        else:
+            print(f"进程 {process.pid} 内存分配失败")
+
+    def request_resource(self, process: Process, os_system: Any, resource_type: str):
+        """
+        请求系统资源
+
+        :param process: 请求资源的进程
+        :param os_system: 操作系统引用
+        :param resource_type: 要请求的资源类型
+        """
+        # 将字符串映射到ResourceType
+        resource_types = {
+            'PRINTER': ResourceType.PRINTER,
+            'DISK': ResourceType.DISK,
+            'NETWORK': ResourceType.NETWORK
+        }
+
+        # 验证并请求资源
+        try:
+            res_type = resource_types[resource_type.upper()]
+            success = os_system.resource_manager.request_resource(process.pid, res_type)
+
+            if success:
+                print(f"进程 {process.pid} 成功分配了 {resource_type}")
+            else:
+                print(f"进程 {process.pid} 资源 {resource_type} 分配失败")
+        except KeyError:
+            print(f"无效的资源类型: {resource_type}")
+
+    def release_resource(self, process: Process, os_system: Any, resource_type: str):
+        """
+        释放先前分配的资源
+
+        :param process: 释放资源的进程
+        :param os_system: 操作系统引用
+        :param resource_type: 要释放的资源类型
+        """
+        # 将字符串映射到ResourceType
+        resource_types = {
+            'PRINTER': ResourceType.PRINTER,
+            'DISK': ResourceType.DISK,
+            'NETWORK': ResourceType.NETWORK
+        }
+
+        try:
+            res_type = resource_types[resource_type.upper()]
+
+            # 查找并释放分配给该进程的此类资源
+            allocations = os_system.resource_manager.resource_allocations.get(process.pid, set())
+            resources_to_release = [
+                res for res in allocations
+                if res.type == res_type
+            ]
+
+            for resource in resources_to_release:
+                os_system.resource_manager.release_resource(process.pid, resource)
+                print(f"进程 {process.pid} 释放了 {resource_type} 资源")
+        except KeyError:
+            print(f"无效的资源类型: {resource_type}")
+
+    def create_file(self, process: Process, os_system: Any, filename: str):
+        """
+        在文件系统中创建文件
+
+        :param process: 创建文件的进程
+        :param os_system: 操作系统引用
+        :param filename: 要创建的文件名
+        """
+        try:
+            success = os_system.file_system.create_file(filename, process.pid)
+            if success:
+                print(f"进程 {process.pid} 创建了文件: {filename}")
+            else:
+                print(f"文件 {filename} 创建失败")
+        except Exception as e:
+            print(f"创建文件 {filename} 时出错: {e}")
+
+    def delete_file(self, process: Process, os_system: Any, filename: str):
+        """
+        从文件系统中删除文件
+
+        :param process: 删除文件的进程
+        :param os_system: 操作系统引用
+        :param filename: 要删除的文件名
+        """
+        try:
+            success = os_system.file_system.delete_file(filename, process.pid)
+            if success:
+                print(f"进程 {process.pid} 删除了文件: {filename}")
+            else:
+                print(f"文件 {filename} 删除失败")
+        except Exception as e:
+            print(f"删除文件 {filename} 时出错: {e}")
+
+    def read_file(self, process: Process, os_system: Any, filename: str, offset: str = '0', size: str = None):
+        """
+        从文件系统中读取文件
+
+        :param process: 读取文件的进程
+        :param os_system: 操作系统引用
+        :param filename: 要读取的文件名
+        :param offset: 文件起始字节偏移量
+        :param size: 要读取的字节数
+        """
+        try:
+            # 将偏移量和大小转换为整数
+            offset_bytes = int(offset)
+            read_size = int(size) if size else None
+
+            content = os_system.file_system.read_file(
+                filename,
+                process.pid,
+                offset_bytes,
+                read_size
+            )
+
+            print(f"进程 {process.pid} 从文件 {filename} 读取: {content}")
+        except Exception as e:
+            print(f"读取文件 {filename} 时出错: {e}")
+
+    def write_file(self, process: Process, os_system: Any, filename: str, offset: str = '0', content: str = ''):
+        """
+        向文件系统中的文件写入内容
+
+        :param process: 写入文件的进程
+        :param os_system: 操作系统引用
+        :param filename: 要写入的文件名
+        :param offset: 文件起始字节偏移量
+        :param content: 要写入的内容
+        """
+        try:
+            # 将偏移量转换为整数
+            offset_bytes = int(offset)
+
+            success = os_system.file_system.write_file(
+                filename,
+                process.pid,
+                offset_bytes,
+                content
+            )
+
+            if success:
+                print(f"进程 {process.pid} 写入了文件 {filename}")
+            else:
+                print(f"文件 {filename} 写入失败")
+        except Exception as e:
+            print(f"写入文件 {filename} 时出错: {e}")
+
+    def optimize_disk_seek(self, process: Process, os_system: Any, *seek_params):
+        """
+        优化磁盘寻道操作
+
+        :param process: 请求磁盘寻道优化的进程
+        :param os_system: 操作系统引用
+        :param seek_params: 磁盘寻道优化的参数
+        """
+        try:
+            # 调用磁盘管理器的寻道优化方法
+            os_system.disk_manager.optimize_seek_operations()
+            print(f"进程 {process.pid} 请求了磁盘寻道优化")
+        except Exception as e:
+            print(f"磁盘寻道优化失败: {e}")

memory_management.py

@@ -0,0 +1,138 @@
+from dataclasses import dataclass, field
+from typing import List, Dict, Optional, Tuple
+import math
+
+
+class MemoryAllocationStrategy:
+    """
+    内存分配策略
+    """
+    FIRST_FIT = 'first_fit'  # 首次适应算法
+    BEST_FIT = 'best_fit'  # 最佳适应算法
+    WORST_FIT = 'worst_fit'  # 最坏适应算法
+
+
+@dataclass
+class MemoryBlock:
+    """
+    表示内存块
+    """
+    start_address: int  # 起始地址
+    size: int  # 内存块大小
+    is_free: bool = True  # 是否空闲
+    process_id: Optional[int] = None  # 占用该内存块的进程ID
+
+
+class MemoryManager:
+    """
+    管理内存分配、释放和虚拟内存
+    """
+
+    def __init__(
+            self,
+            total_memory: int = 1024 * 1024,  # 默认1MB
+            page_size: int = 4096,  # 4KB页大小
+            allocation_strategy: str = MemoryAllocationStrategy.FIRST_FIT
+    ):
+        self.total_memory = total_memory  # 总内存大小
+        self.page_size = page_size  # 页大小
+        self.allocation_strategy = allocation_strategy  # 分配策略
+
+        # 内存块映射
+        self.memory_map: List[MemoryBlock] = [
+            MemoryBlock(0, total_memory)
+        ]
+
+        # 虚拟内存的页表
+        self.page_table: Dict[int, List[Tuple[int, bool]]] = {}
+
+        # 缺页跟踪
+        self.total_memory_accesses = 0
+        self.page_faults = 0
+
+    def allocate_memory(
+            self,
+            process_id: int,
+            memory_size: int
+    ) -> Optional[int]:
+        """
+        为进程分配内存
+
+        :param process_id: 请求内存的进程ID
+        :param memory_size: 要分配的内存大小
+        :return: 分配的内存起始地址，分配失败返回None
+        """
+        # 根据分配策略选择内存分配方法
+        allocation_method = {
+            MemoryAllocationStrategy.FIRST_FIT: self._first_fit_allocation,
+            MemoryAllocationStrategy.BEST_FIT: self._best_fit_allocation,
+            MemoryAllocationStrategy.WORST_FIT: self._worst_fit_allocation
+        }.get(self.allocation_strategy)
+
+        return allocation_method(process_id, memory_size)
+
+    def _first_fit_allocation(
+            self,
+            process_id: int,
+            memory_size: int
+    ) -> Optional[int]:
+        """
+        首次适应内存分配策略
+
+        :param process_id: 请求内存的进程ID
+        :param memory_size: 要分配的内存大小
+        :return: 分配的内存起始地址，分配失败返回None
+        """
+        for i, block in enumerate(self.memory_map):
+            if block.is_free and block.size >= memory_size:
+                # 如果内存块大于请求大小，则分割块
+                if block.size > memory_size:
+                    new_block = MemoryBlock(
+                        block.start_address + memory_size,
+                        block.size - memory_size
+                    )
+                    self.memory_map.insert(i + 1, new_block)
+
+                # 更新原内存块
+                block.is_free = False
+                block.process_id = process_id
+                block.size = memory_size
+
+                return block.start_address
+
+        return None
+
+    def _best_fit_allocation(
+            self,
+            process_id: int,
+            memory_size: int
+    ) -> Optional[int]:
+        """
+        最佳适应内存分配策略
+
+        :param process_id: 请求内存的进程ID
+        :param memory_size: 要分配的内存大小
+        :return: 分配的内存起始地址，分配失败返回None
+        """
+        best_block = None
+        best_block_index = -1
+        smallest_difference = float('inf')
+
+        for i, block in enumerate(self.memory_map):
+            if block.is_free and block.size >= memory_size:
+                difference = block.size - memory_size
+                if difference < smallest_difference:
+                    smallest_difference = difference
+                    best_block = block
+                    best_block_index = i
+
+        if best_block:
+            # 如果内存块大于请求大小，则分割块
+            if best_block.size > memory_size:
+                new_block = MemoryBlock(
+                    best_block.start_address + memory_size,
+                    best_block.size - memory_size
+                )
+                self.memory_map.insert(best_block_index + 1, new_block)
+
+            # 更

process_management.py

@@ -0,0 +1,162 @@
+import enum
+from dataclasses import dataclass, field
+from typing import List, Dict, Optional
+import time
+import heapq
+
+
+class ProcessState(enum.Enum):
+    """操作系统中的进程状态"""
+    NEW = 0  # 进程刚创建
+    READY = 1  # 等待被分配到处理器的进程
+    RUNNING = 2  # 当前正在执行的进程
+    WAITING = 3  # 等待某些事件的进程（I/O、资源分配）
+    TERMINATED = 4  # 已完成执行的进程
+
+
+@dataclass
+class Process:
+    """表示操作系统中的进程"""
+    pid: int
+    script_path: str
+    state: ProcessState = field(default=ProcessState.NEW)
+    priority: int = field(default=0)
+    arrival_time: float = field(default_factory=time.time)
+    start_time: Optional[float] = None
+    completion_time: Optional[float] = None
+    cpu_time: float = 0.0
+    waiting_time: float = 0.0
+
+
+class ProcessManager:
+    """
+    管理进程调度和生命周期
+    实现多种调度算法
+    """
+
+    def __init__(self):
+        self.processes: Dict[int, Process] = {}
+        self.ready_queue: List[Process] = []
+        self.next_pid = 1
+        self.total_processes = 0
+
+    def create_process(self, script_path: str, priority: int = 0) -> Process:
+        """
+        创建新进程
+
+        :param script_path: 进程脚本路径
+        :param priority: 进程优先级（数字越小优先级越高）
+        :return: 创建的进程
+        """
+        process = Process(
+            pid=self.next_pid,
+            script_path=script_path,
+            priority=priority
+        )
+        self.processes[self.next_pid] = process
+        self.next_pid += 1
+        self.total_processes += 1
+
+        # 将进程移至就绪状态
+        self._change_process_state(process, ProcessState.READY)
+
+        return process
+
+    def _change_process_state(self, process: Process, new_state: ProcessState):
+        """
+        改变进程状态并更新相关时间戳
+
+        :param process: 要更新的进程
+        :param new_state: 进程的新状态
+        """
+        old_state = process.state
+        process.state = new_state
+
+        # 跟踪性能指标的计时
+        current_time = time.time()
+        if new_state == ProcessState.RUNNING:
+            process.start_time = current_time
+        elif new_state == ProcessState.TERMINATED:
+            process.completion_time = current_time
+
+    def schedule_process(self) -> Optional[Process]:
+        """
+        选择并调度要运行的进程
+        使用基于优先级的抢占式调度
+
+        :return: 要运行的进程，如果没有就绪进程则返回None
+        """
+        if not self.ready_queue:
+            return None
+
+        # 按优先级对就绪队列排序（数字越小优先级越高）
+        self.ready_queue.sort(key=lambda p: p.priority)
+
+        # 选择最高优先级进程
+        selected_process = self.ready_queue[0]
+        self._change_process_state(selected_process, ProcessState.RUNNING)
+
+        return selected_process
+
+    def terminate_process(self, process: Process):
+        """
+        终止进程并更新其状态
+
+        :param process: 要终止的进程
+        """
+        self._change_process_state(process, ProcessState.TERMINATED)
+
+        # 如果在就绪队列中，则移除
+        if process in self.ready_queue:
+            self.ready_queue.remove(process)
+
+    def get_total_processes(self) -> int:
+        """
+        获取已创建的进程总数
+
+        :return: 进程总数
+        """
+        return self.total_processes
+
+    def calculate_avg_turnaround_time(self) -> float:
+        """
+        计算已完成进程的平均周转时间
+
+        :return: 平均周转时间
+        """
+        completed_processes = [
+            p for p in self.processes.values()
+            if p.completion_time is not None
+        ]
+
+        if not completed_processes:
+            return 0.0
+
+        turnaround_times = [
+            p.completion_time - p.arrival_time
+            for p in completed_processes
+        ]
+
+        return sum(turnaround_times) / len(turnaround_times)
+
+    def calculate_avg_weighted_turnaround_time(self) -> float:
+        """
+        计算平均带权周转时间
+        带权周转时间 = (完成时间 - 到达时间) / CPU时间
+
+        :return: 平均带权周转时间
+        """
+        completed_processes = [
+            p for p in self.processes.values()
+            if p.completion_time is not None and p.cpu_time > 0
+        ]
+
+        if not completed_processes:
+            return 0.0
+
+        weighted_turnaround_times = [
+            (p.completion_time - p.arrival_time) / p.cpu_time
+            for p in completed_processes
+        ]
+
+        return sum(weighted_turnaround_times) / len(weighted_turnaround_times)

resource_management.py

@@ -0,0 +1,143 @@
+from dataclasses import dataclass, field
+from typing import List, Dict, Set
+import threading
+from enum import Enum, auto
+
+
+class ResourceType(Enum):
+    """
+    表示不同类型的系统资源
+    """
+    PRINTER = auto()
+    DISK = auto()
+    MEMORY = auto()
+    NETWORK = auto()
+
+
+@dataclass
+class Resource:
+    """
+    表示系统资源
+    """
+    id: int
+    type: ResourceType
+    is_available: bool = True
+    current_owner: int = None  # 当前使用该资源的进程ID
+
+
+class DeadlockAvoidanceStrategy:
+    """
+    死锁预防和解决的策略
+    """
+    RESOURCE_ALLOCATION_GRAPH = 'resource_allocation_graph'
+    BANKER_ALGORITHM = 'banker_algorithm'
+
+
+class ResourceManager:
+    """
+    管理系统资源分配和死锁预防
+    """
+
+    def __init__(self):
+        # 资源池
+        self.resources: Dict[ResourceType, List[Resource]] = {
+            ResourceType.PRINTER: [Resource(i, ResourceType.PRINTER) for i in range(3)],
+            ResourceType.DISK: [Resource(i, ResourceType.DISK) for i in range(2)],
+            ResourceType.NETWORK: [Resource(i, ResourceType.NETWORK) for i in range(1)],
+        }
+
+        # 跟踪资源请求和分配
+        self.resource_requests: Dict[int, Set[Resource]] = {}
+        self.resource_allocations: Dict[int, Set[Resource]] = {}
+
+        # 死锁预防
+        self.allocation_lock = threading.Lock()
+        self.deadlock_strategy = DeadlockAvoidanceStrategy.BANKER_ALGORITHM
+
+    def request_resource(
+            self,
+            process_id: int,
+            resource_type: ResourceType
+    ) -> bool:
+        """
+        为进程请求资源
+
+        :param process_id: 请求资源的进程ID
+        :param resource_type: 要请求的资源类型
+        :return: 如果资源分配成功，返回True，否则返回False
+        """
+        with self.allocation_lock:
+            # 查找指定类型的可用资源
+            available_resources = [
+                res for res in self.resources[resource_type]
+                if res.is_available
+            ]
+
+            if not available_resources:
+                # 没有可用资源
+                return False
+
+            # 分配第一个可用资源
+            resource = available_resources[0]
+            resource.is_available = False
+            resource.current_owner = process_id
+
+            # 跟踪资源分配
+            if process_id not in self.resource_allocations:
+                self.resource_allocations[process_id] = set()
+            self.resource_allocations[process_id].add(resource)
+
+            return True
+
+    def release_resource(
+            self,
+            process_id: int,
+            resource: Resource
+    ):
+        """
+        释放先前分配给进程的资源
+
+        :param process_id: 释放资源的进程ID
+        :param resource: 要释放的资源
+        """
+        with self.allocation_lock:
+            # 验证进程是否拥有该资源
+            if (resource.current_owner != process_id or
+                    resource.type not in self.resources):
+                return
+
+            # 标记资源为可用
+            resource.is_available = True
+            resource.current_owner = None
+
+            # 从分配中移除
+            if process_id in self.resource_allocations:
+                self.resource_allocations[process_id].discard(resource)
+
+    def detect_deadlock(self) -> bool:
+        """
+        使用资源分配图检测潜在的死锁
+
+        :return: 如果检测到死锁，返回True，否则返回False
+        """
+        # 使用资源分配图进行简单的死锁检测
+        for process, resources in self.resource_allocations.items():
+            for resource in resources:
+                # 检查资源是否循环依赖
+                if resource.current_owner != process:
+                    return True
+
+        return False
+
+    def resolve_deadlock(self):
+        """
+        使用资源抢占解决死锁
+        """
+        if not self.detect_deadlock():
+            return
+
+        # 从进程中抢占资源
+        for process, resources in list(self.resource_allocations.items()):
+            for resource in list(resources):
+                self.release_resource(process, resource)
+                break  # 一次释放一个资源

stimulate_operating_system.py

@@ -0,0 +1,97 @@
+import sys
+import time
+from typing import List, Dict, Any
+from dataclasses import dataclass, field
+
+# 导入其他模块
+from process_management import ProcessManager
+from memory_management import MemoryManager
+from resource_management import ResourceManager
+# from file_system import FileSystem
+# from disk_management import DiskManager
+from command_interpreter import CommandInterpreter
+
+
+@dataclass
+class OperatingSystem:
+    """
+    模拟操作系统核心类
+    """
+    process_manager: ProcessManager = field(default_factory=ProcessManager)
+    memory_manager: MemoryManager = field(default_factory=MemoryManager)
+    resource_manager: ResourceManager = field(default_factory=ResourceManager)
+    # file_system: FileSystem = field(default_factory=FileSystem)
+    # disk_manager: DiskManager = field(default_factory=DiskManager)
+    command_interpreter: CommandInterpreter = field(default_factory=CommandInterpreter)
+
+    def execute_job_script(self, script_path: str):
+        """
+        通过命令解释器执行作业脚本
+
+        :param script_path: 作业脚本文件路径
+        """
+        try:
+            # 读取并解析脚本
+            with open(script_path, 'r') as script_file:
+                script_lines = script_file.readlines()
+
+            # 为脚本创建作业/进程
+            job = self.process_manager.create_process(script_path)
+
+            # 解释并执行命令
+            for line in script_lines:
+                line = line.strip()
+                if line:
+                    self.command_interpreter.execute_command(line, job, self)
+
+            # 完成进程
+            self.process_manager.terminate_process(job)
+
+        except Exception as e:
+            print(f"执行作业脚本 {script_path} 时出错: {e}")
+
+    def run_system(self, job_scripts: List[str]):
+        """
+        并发运行多个作业脚本
+
+        :param job_scripts: 要执行的脚本路径列表
+        """
+        # 模拟并发作业处理
+        for script in job_scripts:
+            try:
+                self.execute_job_script(script)
+            except Exception as e:
+                print(f"作业 {script} 出错: {e}")
+
+        # 计算并显示系统性能指标
+        self.display_system_performance()
+
+    def display_system_performance(self):
+        """
+        显示整体系统性能指标
+        """
+        print("\n--- 系统性能指标 ---")
+        print(f"总进程数: {self.process_manager.get_total_processes()}")
+        print(f"平均周转时间: {self.process_manager.calculate_avg_turnaround_time():.2f}")
+        print(f"平均带权周转时间: {self.process_manager.calculate_avg_weighted_turnaround_time():.2f}")
+        print(f"缺页率: {self.memory_manager.calculate_page_fault_rate():.2%}")
+        # print(f"磁盘寻道优化: {self.disk_manager.get_seek_optimization_metric()}")
+
+
+def main():
+    # 创建操作系统实例
+    os_sim = OperatingSystem()
+
+    # 模拟作业脚本
+    job_scripts = [
+        'job1_script.txt',
+        'job2_script.txt',
+        'job3_script.txt'
+    ]
+
+    # 运行操作系统模拟
+    os_sim.run_system(job_scripts)
+
+
+if __name__ == '__main__':
+    main()