Архитектура компьютера

Процессор твоего телефона с частотой 3 ГГц выполняет 3 миллиарда тактов в секунду, но если написать в Python 0.1 + 0.2 == 0.3, ответ будет False. Оба факта вытекают из устройства компьютера: процессор выбирает и выполняет команды одну за другой, а числа хранит в конечном числе битов. В этом уроке мы изучим те части «железа», которые сильнее всего влияют на программиста.

Архитектура фон Неймана и цикл команд

1. 1
   Выборка (fetch)

   Адрес из PC попадает в MAR, команда читается из памяти в IR, PC переходит к следующей команде.

2. 2
   Декодирование (decode)

   Устройство управления определяет код операции и операнды.

3. 3
   Исполнение (execute)

   АЛУ вычисляет или данные читаются/пишутся в память; команда перехода меняет PC. Затем цикл повторяется.

memory = [('LOAD', 5), ('ADD', 6), ('STORE', 7), ('PRINT', 7), ('HALT', 0), 20, 22, 0]
pc, acc, executed = 0, 0, 0
while True:
    op, addr = memory[pc]
    pc += 1
    executed += 1
    if op == 'LOAD':
        acc = memory[addr]
    elif op == 'ADD':
        acc += memory[addr]
    elif op == 'STORE':
        memory[addr] = acc
    elif op == 'PRINT':
        print('memory[7] =', memory[addr])
    elif op == 'HALT':
        break
print('instructions executed:', executed, '| PC =', pc, '| ACC =', acc)

memory[7] = 42
instructions executed: 5 | PC = 5 | ACC = 42

Иерархия памяти и кэш

Процессор примерно в сто раз быстрее оперативной памяти (RAM) — это «бутылочное горлышко» фон Неймана. Решение — иерархия памяти: маленькие и быстрые уровни кэша рядом с процессором и большие, медленные виды памяти дальше. Кэш опирается на локальность: недавно использованные данные скоро понадобятся снова (временная локальность), как и соседние адреса (пространственная локальность). Поэтому память подгружается строками кэша по 64 байта.

Целые числа: дополнительный код

В n-битном дополнительном коде старший бит имеет отрицательный вес: −2ⁿ⁻¹. Поэтому отрицательные числа начинаются с 1, а отдельный «вычитатель» не нужен: АЛУ вычисляет a − b как a + (−b). Само сложение строится из логических элементов: в полусумматоре бит суммы — a XOR b, а перенос — a AND b.

Числа с плавающей запятой: IEEE 754

import struct, math

def to_bits(x, bits=8):
    return format(x % 2 ** bits, '0' + str(bits) + 'b')

def from_bits(s):
    v = int(s, 2)
    return v - 2 ** len(s) if s[0] == '1' else v

print(to_bits(45), to_bits(-45), from_bits('11010011'))
print('100 + 50 in 8 bits:', from_bits(to_bits(100 + 50)))

raw = struct.pack('>f', -6.25).hex()
print('-6.25 as float32:', raw, format(int(raw, 16), '032b'))
print(0.1 + 0.2, 0.1 + 0.2 == 0.3, math.isclose(0.1 + 0.2, 0.3))
print(struct.unpack('>f', struct.pack('>f', 0.1))[0])

00101101 11010011 -45
100 + 50 in 8 bits: -106
-6.25 as float32: c0c80000 11000000110010000000000000000000
0.30000000000000004 False True
0.10000000149011612