Полный путь одной инструкции
От основ двоичной системы в лекции 1 до системы ввода-вывода в предыдущей лекции мы охватили всё основное содержание принципов организации компьютеров. В этой лекции мы свяжем эти знания в единую линию, проследив полный путь команды от появления до завершения.
Мы реализуем полныйсимулятор компьютера фон Неймана (FullComputer), который включает: четырёхуровневую структуру хранения (жёсткий диск, память, кэш, регистры), передачу данных DMA, четырёхступенчатый конвейер выборки-декодирования-выполнения-записи результата, взаимодействие через шину, статистику попаданий в кэш. В конце выводится полный отчёт о выполнении.
Повторение: карта знаний шести модулей
Прежде чем начать сквозное моделирование, быстро повторим ключевые концепции каждого из шести модулей этого курса:
| Модуль | тема | Основные концепции | Реализация в этой лекции |
|---|---|---|---|
| Модуль 1 | Двоичное представление и представление информации | кодирование 0/1, основание, дополнительный код, плавающая запятая | И инструкции, и данные хранятся в памяти в двоичной форме. |
| Модуль 2 | Логические элементы и цифровые схемы | Логические элементы AND/OR/NOT, сумматоры, АЛУ | Операции АЛУ на этапе выполнения выполняются логическими схемами. |
| Модуль 3 | Архитектура фон Неймана | Пять основных компонентов, хранимая программа, командный цикл | В этой лекции моделируется полная машина фон Неймана. |
| Модуль 4 | Принципы работы процессора | Регистры, PC, IR, конвейер, четыре стадии | Моделируются все четыре стадии выборки-декодирования-выполнения-обратной записи. |
| Модуль 5 | Система хранения | Иерархия памяти, кэш, принцип локальности | Жёсткий диск → память → кэш → регистры, полная цепочка четырёхуровневой системы хранения. |
| Модуль 6 | Шина и ввод-вывод | Шины адреса/данных/управления, опрос/прерывания/DMA | DMA загружает программу, шина передаёт данные, заполнение строки кэша. |
Полный жизненный цикл инструкции
Мы используем простую псевдоинструкциюADD A, B(сложить значения регистров A и B, сохранить результат обратно в A) в качестве примера, чтобы проследить весь её путь:
Этап 1 путешествия: программа хранится на жёстком диске
Изначально программа хранится на жёстком диске в виде файла. Жёсткий диск — этоэнергонезависимое хранилище, данные не теряются после выключения питания, но скорость чтения/записи самая низкая (уровень миллисекунд).
Этап 2 путешествия: DMA загружает программу в память.
Когда вы дважды щёлкаете, чтобы запустить программу, операционная система черезDMAперемещает программу с жёсткого диска в память. Контроллер DMA берёт на себя работу по перемещению данных, и в это время CPU может заниматься другими делами.
Этап 3 путешествия: CPU извлекает инструкцию через шину.
CPU помещает значение счётчика команд (PC) нашину адреса, пошине управленияи подаёт сигнал "чтения". После получения сигнала память помещает инструкцию по соответствующему адресу нашину данных, и CPU считывает её в регистр инструкций (IR).
Шаг 4 путешествия: декодирование — контроллер разбирает команду.
Команда ADD A, B в регистре команд разделяется на три части: код операции ADD, операнд-приёмник A, операнд-источник B. Контроллер определяет следующую операцию по коду операции.
Шаг 5 путешествия: выполнение — АЛУ выполняет операцию.
Контроллер посылает управляющие сигналы, заставляя АЛУ взять значения из регистров A и B, выполнить операцию сложения и временно сохранить результат на выходе АЛУ.
Шаг 6 путешествия: обратная запись — результат сохраняется в регистры через шину данных
Результаты вычисления АЛУ проходят черезшину данныхи записываются обратно в регистр A. На этом выполнение одной команды завершено. PC автоматически увеличивается на 1, чтобы указывать на следующую команду.
Демонстрация кода: полная симуляция FullComputer.
Класс FullComputer ниже полностью моделирует весь описанный выше процесс. Он содержит более 300 строк кода, охватывая материал всех шести модулей этого курса. Каждый шаг выводит подробные логи.
Пример
FullComputer — полный симулятор компьютера фон Неймана (пример учебной демонстрации)
Эта программа реализует полный (упрощённый) компьютер фон Неймана, включая:
- Четырёхуровневое хранилище: Диск → Память → Кэш → Регистр
- DMA-контроллер: автоматически перемещает программы с жёсткого диска в память
- Три типа шин: шина адреса, шина данных, шина управления.
- fourPhaseExecute: выборка команды (Fetch) → translatecode (Decode) → выполнение (Execute) → запись обратно (WriteBack)
- Система статистики: доля попаданий в кэш, количество инструкций, количество использований шины, время выполнения
Поддерживаемые инструкции:
LOAD reg value - Загрузить непосредственное значение в регистр
STORE reg addr - Сохранить значение регистра по адресу памяти
ADD dst src - dst = dst + src
SUB dst src - dst = dst - src
MUL dst src - dst = dst * src
CMP a b - Сравнить два значения, установить флаги
JMP addr - Безусловный переход
JZ addr - Переход, если флаг нуля истинен
Как запустить: python fullcomputer.py
"""
import time
# ============================
# 1. Система хранения — четырёхуровневая структура
# ============================
class Disk:
"""
Жесткий диск — низкоуровневое энергонезависимое хранилище.
Самая низкая скорость (уровень миллисекунд), наибольшая ёмкость, данные не теряются при отключении питания.
"""
def __init__(self):
self.sectors = {} # Хранение секторов, имитация секторов жесткого диска
self.read_latency = 5 # Задержка чтения (модельная единица времени)
self.write_latency = 8 # Задержка записи
def load_program(self, program_name):
Загрузить программу, хранящуюся на жестком диске. Вернуть None, если программы не существует.
if program_name in self.sectors:
print(f" [жесткий диск] найдена последовательность курса '{program_name}',Размер: {len(self.sectors[program_name])} директив")
return self.sectors[program_name]
print(f[Жёсткий диск] Программа '{program_name}' не найдена!)
return None
def store_program(self, name, program):
"""Сохранить программу на жёсткий диск"""
self.sectors[name] = program
print(f" [жёсткий диск] Сохранена последовательность программы '{name}' ({len(program)} инструкций) в сектор 0x{hash(name) & 0xFFFF:04X}")
class Memory:
"""
Основная память — хранилище второго уровня.
Средняя скорость (уровень наносекунд), большая ёмкость, данные теряются при отключении питания.
ЦП может напрямую обращаться только к данным в памяти (не может напрямую обращаться к жёсткому диску).
"""
def __init__(self, size=65536):
self.size = size # Размер памяти (байты)
self.cells = {} # Единица памяти: ключ — адрес, значение — данные/команда
self.read_count = 0 # Количество операций чтения
self.write_count = 0 # Количество операций записи
def read(self, addr):
Чтение данных по указанному адресу
self.read_count += 1
if addr not in self.cells:
print(f" Предупреждение: адрес {addr} не инициализирован, возвращается 0")
return 0
return self.cells[addr]
def write(self, addr, data):
Запись данных по указанному адресу
self.write_count += 1
self.cells[addr] = data
def load_block(start_addr, data_block, data_block):
"""
Загрузить весь блок данных в непрерывную область памяти.
Для сценариев пакетной передачи DMA.
"""
for i, item in enumerate(data_block):
self.cells[start_addr + i] = item
return len(data_block)
class Cache:
"""
Cache (симуляция L1-кэша) - хранилище третьего уровня.
Чрезвычайно быстрый (та же частота, что у CPU), наименьшая ёмкость.
Использование простой модели кэша с прямым отображением:
- Каждая строка кэша хранит: (адрес памяти, содержимое данных)
- Попадание в кэш: данные уже находятся в кэше, возвращаются напрямую
Промах кэша: нужно загрузить из памяти, заменить строку кэша.
"""
def __init__(self, num_lines=8):
self.num_lines = num_lines
self.lines = {} # Строка кэша: {cache_line_index: (mem_addr, data)}
self.hit_count = 0
self.miss_count = 0
def read(self, mem_addr, memory):
"""
Чтение из кэша. При попадании вернуть сразу; при промахе загрузить из памяти.
Возвращает: (data, was_hit)
"""
# Простое отображение: индекс строки кэша = адрес памяти % количество строк кэша
line_index = mem_addr % self.num_lines
if line_index in self.lines:
cached_addr, cached_data = self.lines[line_index]
if cached_addr == mem_addr:
# Попадание в кэш
self.hit_count += 1
print(f" [Кэширование] попадание!строка {line_index}, Адрес {mem_addr}, Данные: {cached_data}")
return cached_data, True
# Промах кэша
self.miss_count += 1
data = memory.read(mem_addr)
self.lines[line_index] = (mem_addr, data)
print(f" [Caching] промах, fromMemory адрес {mem_addr} addloadData {data} → Cachingline {line_index}")
return data, False
@property
def hit_rate(self):
total = self.hit_count + self.miss_count
return self.hit_count / total * 100 if total > 0 else 0.0
class RegisterFile:
"""
Регистровый файл — самое верхнее хранилище.
Самый быстрый (один такт), самая маленькая ёмкость.
Регистры общего назначения + регистры специального назначения (PC, IR, MAR, MDR, FLAGS)
"""
def __init__(self):
# Регистры общего назначения
self.gpr = {'A': 0, 'B': 0, 'C': 0, 'D': 0}
# Регистры специального назначения
self.PC = 0 # Счётчик команд: хранит адрес следующей команды
self.IR = None # Регистр команд: хранит текущую выполняемую команду
self.MAR = 0 # Регистр адреса памяти: хранит адрес памяти, к которому будет осуществлён доступ
self.MDR = 0 # Регистр данных памяти: хранит данные, считанные из памяти / предназначенные для записи в память
# Регистр флагов
self.FLAGS = {'Z': False} # Флаг нуля: равен ли результат предыдущей операции 0
def __repr__(self):
gpr_str = ', '.join(f'{k}={v}' for k, v in self.gpr.items())
return f"GPR[{gpr_str}] PC={self.PC} IR={self.IR} FLAGS={self.FLAGS}"
# ============================
# 2. Система шин — три шины
# ============================
class SystemBus:
"""
Системная шина — включает шину адреса, шину данных, шину управления.
Обеспечивает унифицированный интерфейс для CPU, памяти и DMA.
"""
def __init__(self):
self.address_bus = 0 # Шина адреса: адрес, передаваемый в данный момент
self.data_bus = 0 # Шина данных: данные, передаваемые в данный момент
self.control = 'IDLE' # Шина управления: IDLE, READ, WRITE, INTERRUPT, DMA_REQ, DMA_ACK
self.transfer_count = 0 # Количество передач по шине
def cpu_read(self, address, memory, cache):
"""
CPU читает данные из памяти через шину (посредством кэша).
Полный процесс взаимодействия с шиной:
1. CPU помещает адрес на шину адреса
2. CPU подаёт сигнал READ на шину управления.
3. Память (через слой кэша) возвращает данные на шину данных
4. CPU считывает данные с шины данных
5. Очистить шину
"""
self.address_bus = address
self.control_bus = 'READ'
self.transfer_count += 1
print(f[Шина] шина адреса ← {address}, шина управления ← READ)
# Память отвечает через слой кэша
data, was_hit = cache.read(address, memory)
self.data_bus = data
print(f" [шина] Шина данных ← {data} {'(Попадание в кэш)' if was_hit else '(пришло из памяти)'}")
# CPU читает данные
result = self.data_bus
# Очистка шины
self.address_bus = 0
self.data_bus = 0
self.control_bus = 'IDLE'
print(f[Bus] Шина очищена, переход в состояние простоя)
return result
def cpu_write(self, address, data, memory):
"""
CPU записывает данные в память через шину.
"""
self.address_bus = address
self.data_bus = data
self.control_bus = 'WRITE'
self.transfer_count += 1
print(f[Bus] Шина адреса ← {address}, Шина данных ← {data}, Шина управления ← WRITE)
memory.write(address, data)
print(f[Bus] Данные {data} были записаны по адресу памяти {address})
# Очистка шины
self.address_bus = 0
self.data_bus = 0
self.control_bus = 'IDLE'
print(f[Bus] Шина очищена, переход в состояние простоя)
# ============================
# 3. Контроллер DMA
# ============================
class DMAController:
"""
DMA-контроллер - отвечает за прямую передачу данных между жестким диском и памятью.
ЦП необходимо только сообщить DMA: адрес источника, адрес назначения, длину передачи.
После завершения передачи DMA уведомляет ЦП с помощью прерывания.
"""
def __init__(self, bus):
self.bus = bus
self.transfer_count = 0 # Количество передач DMA
self.total_bytes = 0 # Общее количество переданных байт
def transfer_program(self, disk, program_name, memory, load_addr=0):
"""
Загрузить программу с жёсткого диска в память через DMA.
Это практическое применение лекции 20 «Режим DMA» в этом курсе.
"""
print(f"\n {'='*50}")
print(fПередача DMA начинается: жёсткий диск → память)
print(f" {'='*50}")
print(f[DMA] Источник: сектор жёсткого диска (программа '{program_name}'))
print(f[DMA] Назначение: начало адреса памяти 0x{load_addr:04X})
print(f[DMA] Запрос управления шиной...)
# DMA занимает шину
self.bus.control_bus = 'DMA_REQ'
print(f[DMA] получает управление шиной (шина управления ← DMA_REQ))
program = disk.load_program(program_name)
if program is None:
print(f[DMA] Ошибка: программа не существует, передача прервана)
self.bus.control_bus = 'IDLE'
return 0
# Пошаговая передача инструкций
for i, instruction in enumerate(program):
addr = load_addr + i
memory.write(addr, instruction)
self.bus.address_bus = addr
self.bus.data_bus = instruction
self.total_bytes += 1
self.transfer_count += 1
print(f" [DMA] передача #{i}: Директива '{instruction}' → Адрес памяти {addr} (0x{addr:04X})")
# DMA освобождает шину и отправляет прерывание завершения
self.bus.control_bus = 'DMA_ACK'
print(f" [DMA] передача завершена! Всего {len(program)} директив, {self.total_bytes} передач по шине")
print(f[DMA] Освобождение управления шиной (шина управления ← IDLE))
# Прерывание уведомляет процессор
print(f" [DMA] Отправить сигнал прерывания, чтобы уведомить процессор: загрузка программы завершена")
self.bus.control_bus = 'INTERRUPT'
# Обработка после получения прерывания процессором
time.sleep(0.001)
print(f[Ответ процессора на прерывание] Получено прерывание завершения DMA, программа готова)
self.bus.control_bus = 'IDLE'
return len(program)
def cache_prefetch(self, memory, cache, start_addr, count):
"""
Предварительная выборка DMA: заранее загрузить данные, которые скоро будут использованы, из памяти в кеш.
Смоделировать механизм аппаратной предварительной выборки современного процессора.
"""
print(f"\n[Предварительная выборка DMA] Предзагрузить адреса памяти {start_addr}~{start_addr+count-1} в кеш...)
for i in range(count):
addr = start_addr + i
data = memory.read(addr)
line_index = addr % cache.num_lines
cache.lines[line_index] = (addr, data)
print(f[DMA Prefetch] Завершено, {count} инструкций записано в кэш)
# ============================
# 4. ALU - арифметико-логическое устройство
# ============================
class ALU:
"""
Арифметико-логическое устройство - выполняет все арифметические и логические операции.
Материал, соответствующий второму модулю курса, например сумматоры и логические элементы.
"""
@staticmethod
def add(a, b):
print(f[ALU] Выполняется сложение: {a} + {b} = {a + b})
return a + b
@staticmethod
def sub(a, b):
print(f[ALU] Выполнение вычитания: {a} - {b} = {a - b})
return a - b
@staticmethod
def mul(a, b):
print(f[ALU] Выполнение умножения: {a} * {b} = {a * b})
return a * b
@staticmethod
def cmp(a, b):
result = (a == b)
print(f" [ALU] ExecuteCompare: {a} == {b} ? {'is' if result else 'no'} (Z={1 if result else 0})")
return result
# ============================
# 5. FullComputer - Полный компьютер
# ============================
class FullComputer:
"""
Симулятор полного компьютера фон Неймана.
Компоненты:
- диск: жёсткий диск (энергонезависимое хранилище)
- память: основная память
- кэш: L1-кэш
- registers: группа регистров (включая PC, IR, MAR, MDR, FLAGS)
- alu: арифметико-логическое устройство
- bus: системная шина (адрес + данные + управление)
- dma: контроллер DMA
Поток выполнения:
1. Загрузка: DMA переносит программу с жёсткого диска в память.
2. Цикл команды: выборка → декодирование → исполнение → обратная запись.
3. Сгенерировать полный отчёт о выполнении
"""
def __init__(self):
print("=" * 60)
print(FullComputer - инициализация компьютера фон Неймана...)
print("=" * 60)
# Четырёхуровневая система хранения
self.disk = Disk()
self.memory = Memory()
self.cache = Cache(num_lines=8)
self.registers = RegisterFile()
# Вычислительное устройство
self.alu = ALU()
# Шинная система
self.bus = SystemBus()
# DMA-контроллер
self.dma = DMAController(self.bus)
# Статистика
self.instructions_executed = 0
self.clock_cycles = 0
print(Компоненты готовы: жёсткий диск, память (64KB), кэш (8-строчный L1), 4 регистра общего назначения)
print(Компоненты готовы: АЛУ, системная шина, DMA-контроллер)
print()
def store_program(self, name, program):
"""Сохранить программу на жёсткий диск"""
print(f[Шаг 0] Сохранить программу '{name}' на жёсткий диск)
self.disk.store_program(name, program)
print()
def load_program(self, program_name, load_addr=0):
"""
Загрузить программу: DMA передаёт данные с жёсткого диска в память.
"""
print(f[Шаг 1] DMA загружает программу в память)
size = self.dma.transfer_program(
self.disk, program_name, self.memory, load_addr
)
print()
# Предварительная выборка инструкций в кэш
print(f[Шаг 2] Прогрев кэша: предварительная выборка первых {min(4, size)} инструкций)
self.dma.cache_prefetch(self.memory, self.cache, load_addr, min(4, size))
print()
# Установить PC на начальный адрес программы
self.registers.PC = load_addr
print(f[Шаг 3] Установить PC ← {load_addr} (начальный адрес программы))
print()
def fetch(self):
"""
Этап 1: Выборка
- Поместить значение PC в MAR
- Отправить адрес по шине адреса
- Отправить сигнал READ по шине управления
- Извлечь команду из шины данных (через слой кэша)
- Сохранить команду в IR
- Инкремент PC
"""
print(f"--- Этап 1: Выборка команды (Fetch) ---")
self.clock_cycles += 1
# MAR ← PC
self.registers.MAR = self.registers.PC
print(f" MAR ← PC = {self.registers.PC}")
# Чтение памяти через шину (через кэш)
instruction = self.bus.cpu_read(
self.registers.MAR, self.memory, self.cache
)
# MDR ← шина данных, IR ← MDR
self.registers.MDR = instruction
self.registers.IR = instruction
print(f" MDR ← {instruction}, IR ← MDR")
# Инкремент PC
old_pc = self.registers.PC
self.registers.PC += 1
print(f" PC ← {old_pc} + 1 = {self.registers.PC}")
return instruction
def decode(self):
"""
Этап 2: Декодирование
- Контроллер декодирует инструкцию в IR
- Отделить код операции от операнда
- Определить операции этапа выполнения
"""
print(f--- Этап 2: Декодирование ---)
self.clock_cycles += 1
instruction = self.registers.IR
parts = instruction.split()
opcode = parts[0]
operands = parts[1:] if len(parts) > 1 else []
print(f" Инструкция: '{instruction}'")
print(fКод операции: {opcode}, операнды: {operands})
return opcode, operands
def execute(self, opcode, operands):
"""
Этап 3: Выполнение
- Выполнить соответствующую операцию на основе кода операции
- АЛУ участвует в арифметических/логических операциях
- Может изменять регистры или устанавливать биты флагов
"""
print(f--- Фаза 3: Выполнение ---)
self.clock_cycles += 1
if opcode == 'LOAD':
# LOAD reg value: Загрузить непосредственное значение в регистр
reg, value = operands[0], int(operands[1])
self.registers.gpr[reg] = value
print(fОперация: загрузить непосредственное значение {value} → регистр {reg})
print(f" АЛУ не участвует (прямая загрузка)")
elif opcode == 'STORE':
# STORE reg addr: Сохранить значение регистра в память
reg, addr = operands[0], int(operands[1])
value = self.registers.gpr[reg]
print(fОперация: подготовка к сохранению значения {value} регистра {reg} в адрес памяти {addr})
# Данные готовы; этап обратной записи выполняет фактическую операцию сохранения.
return ('STORE', reg, addr, value)
elif opcode == 'ADD':
# ADD dst src: dst = dst + src
dst, src = operands[0], operands[1]
old_val = self.registers.gpr[dst]
result = self.alu.add(old_val, self.registers.gpr[src])
self.registers.gpr[dst] = result
# Установить флаг нуля
self.registers.FLAGS['Z'] = (result == 0)
print(f" Операция: {dst} ← {old_val} + {self.registers.gpr.get(src, src)} = {result}")
print(f"Флаг нуля Z ← {self.registers.FLAGS['Z']}")
elif opcode == 'SUB':
# SUB dst src: dst = dst - src
dst, src = operands[0], operands[1]
old_val = self.registers.gpr[dst]
result = self.alu.sub(old_val, self.registers.gpr[src])
self.registers.gpr[dst] = result
self.registers.FLAGS['Z'] = (result == 0)
print(f" Операция: {dst} ← {old_val} - {self.registers.gpr.get(src, src)} = {result}")
elif opcode == 'MUL':
# MUL dst src: dst = dst * src
dst, src = operands[0], operands[1]
old_val = self.registers.gpr[dst]
result = self.alu.mul(old_val, self.registers.gpr[src])
self.registers.gpr[dst] = result
self.registers.FLAGS['Z'] = (result == 0)
print(f" Операция: {dst} ← {old_val} * {self.registers.gpr.get(src, src)} = {result}")
elif opcode == 'CMP':
# CMP a b: сравнить два значения регистров, установить флаг нуля
a, b = operands[0], operands[1]
is_equal = self.alu.cmp(
self.registers.gpr[a],
self.registers.gpr[b]
)
self.registers.FLAGS['Z'] = is_equal
elif opcode == 'JMP':
# JMP addr: Безусловный переход
target = int(operands[0])
print(fОперация: безусловный переход по адресу {target})
old_pc = self.registers.PC
self.registers.PC = target
print(fPC ← {old_pc} → {target} (переход))
elif opcode == 'JZ':
# JZ addr: переход, если флаг нуля истинен
target = int(operands[0])
if self.registers.FLAGS['Z']:
print(fОперация: если флаг нуля истинен (Z=1), переход по адресу {target})
self.registers.PC = target
else:
print(fОперация: флаг нуля ложен (Z=0), перехода нет, последовательное выполнение)
elif opcode == 'HALT':
# HALT: останов
print(fОперация: инструкция Halt, программа завершается)
return 'HALT'
else:
print(f" Неизвестный код операции: {opcode}")
return None
def writeback(self):
"""
Этап 4: WriteBack
- Если есть операции, которым нужно выполнить запись обратно в память (например, STORE), они завершаются на этом этапе
- Передача данных через шину данных
"""
print(f"--- Этап 4: WriteBack ---")
self.clock_cycles += 1
# Результат обычной инструкции уже записан в регистр на этапе выполнения
# Инструкции STORE необходимо выполнить запись в память на этом этапе
print(fСостояние регистров: {self.registers.gpr})
print(fРегистр флагов: {self.registers.FLAGS})
def writeback_store(self, addr, value):
"""Операция обратной записи инструкции STORE — запись в память через шину"""
self.bus.cpu_write(addr, value, self.memory)
print(fSTORE завершено: {value} → адрес памяти {addr})
def run(self):
"""
Запустить загруженную программу.
Повторять: выборка → декодирование → выполнение → обратная запись, пока программа не завершится.
"""
print("=" * 60)
print(Программа начинает выполнение)
print("=" * 60)
while self.registers.PC < max(self.memory.cells.keys(), default=0) + 1:
# Проверить, находится ли PC в допустимом диапазоне
if self.registers.PC not in self.memory.cells:
# PC превышает диапазон программы, возможно, из-за перехода в конец, завершить работу
print(f"\nСчетчик команд PC={self.registers.PC} превышает диапазон программы, выполнение завершается)
break
self.instructions_executed += 1
print(f"\n{'#' * 55}")
print(f"### Директива #{self.instructions_executed} | PC = {self.registers.PC}")
print(f"{'#' * 55}")
# Выборка инструкции
instruction = self.fetch()
# Декодирование
opcode, operands = self.decode()
# Выполнить
special = self.execute(opcode, operands)
# Обработка инструкции HALT
if special == 'HALT':
self.clock_cycles += 1
break
# Обратная запись
if special and special[0] == 'STORE':
_, reg, addr, value = special
self.writeback_store(int(addr), value)
else:
self.writeback()
# Проверка безопасности: предотвратить бесконечные циклы
if self.instructions_executed > 1000:
print("\nПредупреждение: выполнено более 1000 инструкций, принудительная остановка (возможен бесконечный цикл))
break
print(f"\n{'=' * 60}")
print(f" Выполнение программы завершено")
print(f"{'=' * 60}")
def report(self):
"""
Сгенерировать полный отчёт о выполнении.
Обобщить всю статистику: доля попаданий в кэш, количество инструкций, тактовые циклы,
Количество передач по шине, количество чтений/записей в память и т. д.
"""
print(f"\n{'=' * 65}")
print(fОтчёт о выполнении FullComputer —— ПРИМЕР)
print(f"{'=' * 65}")
print()
# Основная информация
print(f" {'─' * 55}")
print(f" Основная информация")
print(f" {'─' * 55}")
print(fВсего выполнено инструкций: {self.instructions_executed:>6d})
print(fВсего тактовых циклов: {self.clock_cycles:>6d} циклов)
if self.instructions_executed > 0:
cpi = self.clock_cycles / self.instructions_executed
print(fСредний CPI (циклов/инструкцию): {cpi:>6.2f})
print()
# Производительность кэша
print(f" {'─' * 55}")
print(f"Производительность кэша (L1 Cache)")
print(f" {'─' * 55}")
total_access = self.cache.hit_count + self.cache.miss_count
print(f" Попаданий в кэш: {self.cache.hit_count:>6d} раз")
print(f" Промахов кэша: {self.cache.miss_count:>6d} раз")
print(fВсего обращений: {total_access:>6d} раз)
print(fПроцент попаданий: {self.cache.hit_rate:>6.1f}%)
print(fВсего строк кэша: {self.cache.num_lines:>6d} строк)
print()
# Обращения к памяти
print(f" {'─' * 55}")
print(f" Статистика обращений к памяти")
print(f" {'─' * 55}")
print(fОпераций чтения памяти: {self.memory.read_count:>6d} раз)
print(fОпераций записи в память: {self.memory.write_count:>6d} раз)
print(f" Всего обращений к памяти: {self.memory.read_count + self.memory.write_count:>6d} раз")
print(fЧисло используемых адресов памяти: {len(self.memory.cells):>6d})
print()
# Статистика шины
print(f" {'─' * 55}")
print(f" Статистика шины")
print(f" {'─' * 55}")
print(f" Передач по шине, инициированных CPU: {self.bus.transfer_count:>6d} раз")
print(f" Передач по шине, инициированных DMA: {self.dma.transfer_count:>6d} раз")
total_bus = self.bus.transfer_count + self.dma.transfer_count
print(fОбщее количество передач по шине: {total_bus:>6d} раз)
print()
# Конечное состояние регистров
print(f" {'─' * 55}")
print(f" Конечное состояние регистров")
print(f" {'─' * 55}")
print(fРегистры общего назначения: {self.registers.gpr})
print(fСчётчик команд PC: {self.registers.PC})
print(fРегистр команд IR: {self.registers.IR})
print(fРегистр флагов FLAGS: {self.registers.FLAGS})
print()
# Дамп данных памяти (показывает только данные по допустимым адресам)
print(f" {'─' * 55}")
print(f" Дамп данных памяти (показывает только область программы)")
print(f" {'─' * 55}")
if self.memory.cells:
for addr in sorted(self.memory.cells.keys()):
val = self.memory.cells[addr]
print(fАдрес {addr:>4d} (0x{addr:04X}): {val})
else:
print(f" (Память пуста)")
print()
print(f"{'=' * 65}")
print(fКонец отчёта. Спасибо за использование симулятора EXAMPLE FullComputer!)
print(f"{'=' * 65}")
# ============================
# 6. Основная программа - сквозная демонстрация
# ============================
if __name__ == "__main__":
print()
print("╔" + "═" * 58 + "╗")
print("║" + Полный путь одной инструкции — демонстрация EXAMPLE FullComputer.center(52) + "║")
print("╚" + "═" * 58 + "╝")
print()
# Создать компьютер
computer = FullComputer()
# Определить демонстрационную программу: вычислить (10 + 7) * 2 - 3 = ?
# Используйте LOAD для загрузки начального значения, а ADD/MUL/SUB для выполнения вычисления
demo_program = [
"LOAD A 10", # A = 10
"LOAD B 7", # B = 7
"ADD A B", # A = A + B = 17
"LOAD C 2", # C = 2
"MUL A C", # A = A * C = 34
"LOAD D 3", # D = 3
"SUB A D", # A = A - D = 31
"STORE A 100", # Сохранить результат по адресу памяти 100
"LOAD B 31", # B = 31 (ожидаемый результат)
"CMP A B", # Сравнить A и B -> должны быть равны
"JZ 12", # Если равно (Z=1), перейти к HALT
"LOAD D 0", # (не выполняется) D = 0
"HALT", # Останов
]
# Шаг 1: Сохранить программу на жёсткий диск
computer.store_program("EXAMPLE_DEMO", demo_program)
# Шаг 2: DMA-загрузка в память
computer.load_program("EXAMPLE_DEMO", load_addr=0)
# Шаг 3: Запустить программу
computer.run()
# Шаг 4: Вывести полный отчёт о выполнении
computer.report()
print(f"\n")
print(fОбзор: эта демонстрация охватывает все шесть модулей курса «Принципы организации компьютеров»:)
print(fМодуль 1 (двоичный): Команды и данные хранятся в памяти в двоичном кодировании.)
print(fМодуль 2 (Логические элементы): операции ADD/SUB/MUL на этапе выполнения реализуются логическими схемами ALU)
print(fМодуль 3 (фон Неймана): программа и данные совместно используют память, пять основных компонентов работают вместе)
print(fМодуль 4 (Принципы CPU): выборка PC → декодирование IR → выполнение ALU → запись обратно, полный четырёхступенчатый конвейер.)
print(fМодуль 5 (Система памяти): жёсткий диск → память → кэш → регистры, четырёхуровневая иерархия памяти)
print(fМодуль 6 (Шина и ввод-вывод): взаимодействие трёх шин, загрузка программы через DMA, уведомление о прерывании)
print()
Интерпретация отчёта о выполнении
После запуска приведённого выше кода FullComputer выводит подробный отчёт о выполнении. Давайте разберём ключевые метрики:
коэффициент попаданий в кэш
Показанный в отчёте коэффициент попаданий в кэш отражаетвременную локальностьипространственную локальностьпрограммы. Поскольку наша демонстрационная программа очень мала и DMA предзагружает первые 4 инструкции, коэффициент попаданий будет относительно высоким. В реальных больших программах коэффициент попаданий в кэш обычно выше 90% — именно в этом и заключается назначение кэша.
CPI (тактов на инструкцию)
В нашей упрощённой модели каждая инструкция занимает фиксированные 4 такта (выборка-декодирование-выполнение-запись обратно), поэтому CPI примерно равен 4. Современные CPU используют конвейеризацию, чтобы снизить CPI почти до 1 — то есть завершать одну инструкцию за такт.
Количество передач по шине
Количество передач по шине = передачи, инициированные CPU + передачи, инициированные DMA. DMA выполняет большое количество передач на этапе загрузки программы, а CPU инициирует как минимум одну передачу чтения на этапе выборки инструкции для каждой инструкции.
Что мы узнали — обзор шестинедельного курса.
Шесть недель назад мы начали с простейшего вопроса: «Почему компьютеры понимают только 0 и 1?» Теперь мы можем с нуля построить полноценный симулятор компьютера. Давайте ещё раз пройдём этот путь обучения:
| номер недели | Модуль | Ключевые выводы |
|---|---|---|
| Неделя 1 | Двоичное представление и представление информации | Поняли, почему компьютеры используют двоичную систему, как выполнять преобразование систем счисления и как различные виды информации (числа, текст, изображения) кодируются в 0 и 1. |
| Неделя 2 | Логические элементы и цифровые схемы | Освоили три базовых логических элемента: AND, OR, NOT; поняли, как строить сумматоры и АЛУ с их помощью. |
| Неделя 3 | Архитектура фон Неймана | Поняли разделение обязанностей между пятью основными компонентами (арифметическое устройство, устройство управления, память, ввод, вывод) и концепцию хранимой программы. |
| Неделя 4 | Принципы работы процессора | Освоены четыре этапа командного цикла: выборка-декодирование-выполнение-запись результата, а также то, как конвейеризация повышает эффективность. |
| Неделя 5 | Система хранения | Поняли четырёхуровневую пирамиду памяти от регистров до жёсткого диска и то, как кэш использует принцип локальности для ускорения доступа. |
| Неделя 6 | Шина и ввод-вывод | Освоили совместную работу трёх шин (адресной/данных/управления) и различия в эффективности между тремя методами ввода-вывода (опрос/прерывание/DMA). |
От теории к практике: куда двигаться дальше.
Этот курс заложил прочную основу в области принципов организации компьютеров. Если вам интересно углублённое изучение, вот несколько рекомендуемых направлений:
- Операционная система: Узнайте, как операционные системы управляют процессором, памятью, файловыми системами и устройствами ввода-вывода. «Прерывания», «DMA» и «иерархия памяти», изученные в этом курсе, являются ключевыми понятиями операционных систем.
- Язык ассемблера: Взаимодействуйте напрямую с инструкциями процессора. После прохождения этого курса язык ассемблера больше не «книга за семью печатями» — вы знаете, как каждая инструкция ассемблера выполняется на аппаратном уровне.
- nand2tetris: Известный онлайн-курс, который ведёт вас от одного вентиля NAND к постепенному созданию полноценного программируемого компьютера. Содержание этого курса во многом дополняет его.
- Архитектура компьютера: Углубитесь в передовые методы проектирования процессоров, такие как конвейеризация, суперскалярное выполнение, внеочередное выполнение и предсказание переходов.
- Встраиваемые системы: Применяйте знания из этого курса к микроконтроллерам (например, Arduino, STM32), создавая программы, которые напрямую управляют регистрами и периферийными устройствами.
Итоги и заключительная проверка
Итог в одном предложении:Компьютер — это не магия — это слой за слоем тщательно спроектированная абстракция: начиная с транзисторов, которые открываются и закрываются, постепенно строя логические элементы, АЛУ, ЦП, систему памяти, шину и в конечном счёте образуя универсальное устройство, способное выполнять любую последовательность команд. Понимая эти уровни, вы по-настоящему правильно понимаете компьютер.
Комплексные вопросы для самопроверки по курсу
- В симуляторе FullComputer при выполнении инструкции LOAD на каких этапах используются соответственно шина адреса, шина данных и шина управления?
- Если кэш FullComputer имеет только 4 строки (вместо 8), как это влияет на эффективность выполнения программы? Как это явление называется в компьютерной архитектуре?
- В каких сценариях современные операционные системы используют опрос, прерывания и DMA? Приведите по одному примеру для каждого, который можно наблюдать при повседневном использовании компьютера.
Эталонный ответ: 1. Этап выборки: шина адреса передаёт значение PC (адрес инструкции), шина управления посылает сигнал READ, а шина данных возвращает содержимое инструкции. 2. Больше конфликтов кэша, ниже процент попаданий (называется cache thrashing или конфликтными промахами). 3. Опрос: проверка прогресса во время обновления прошивки на некоторых простых встраиваемых устройствах; Прерывание: каждое нажатие клавиши клавиатуры вызывает прерывание; DMA: копирование больших файлов, передача кадрового буфера при рендеринге видеокартой.
Другие расширения