Symulacja IAS
Pierwszym i najważniejszym komputerem Johna von Neumanna była Maszyna IAS (znana też jako IAS machine), budowana w latach 1946–1951 w Instytucie Studiów Zaawansowanych w Princeton. To właśnie na niej wdrożono przełomową koncepcję przechowywania programu i danych w tej samej pamięci operacyjnej (tzw. Stored-Program concept). [1, 2, 3]
Zamiast pisać kolejny generator konsolowy, w przypadku komputera von Neumanna kluczem jest pokazanie tzw. cyklu rozkazowego (Fetch-Decode-Execute), czyli sposobu, w jaki procesor pobiera instrukcje z pamięci, przetwarza je i zapisuje w akumulatorze. [4, 5, 6]
Oto dwa najlepsze rozwiązania prezentacyjne – darmowy interaktywny symulator webowy (idealny do przekazania słuchaczom) oraz gotowy skrypt w Pythonie (generujący czysty plik GIF), który w graficzny sposób wizualizuje słynne „wąskie gardło von Neumanna” (części sterujące i rejestry pracujące na wspólnej pamięci). [7]
1. Interaktywny Symulator Webowy dla Słuchaczy
- Nazwa narzędzia: IAS Simulator (IC-Unicamp) [8]
- Dlaczego warto: To oficjalny, czysty, akademicki emulator pierwszej maszyny von Neumanna. Posiada w pełni graficzny interfejs pokazujący mapę pamięci (Main Memory), jednostkę sterującą (Control Unit z rejestrami PC, IR, IBR, MAR) oraz jednostkę arytmetyczno-logiczną (ALU z Akumulatorem AC i rejestrem MQ). [6, 8]
- Zastosowanie: Słuchacze mogą w przerwie załadować prosty program w assemblerze (np. dodawanie dwóch liczb) i klikając przycisk "Next Cycle" obserwować, jak liczby fizycznie przeskakują między pamięcią a rejestrami procesora. [4, 8]
2. Gotowy kod w Pythonie – Animacja Pracy Procesora (Do pliku GIF)
Poniższy kod tworzy okno o wymiarach 650x450 pikseli i generuje plik von_neumann_cycle.gif.
Animacja symuluje nieustanny, bezobsługowy cykl pracy procesora IAS. Wizualizuje ona, jak Jednostka Sterująca pobiera rozkaz (Fetch), Jednostka ALU wykonuje operację (Execute), a wynik trafia do pamięci lub Akumulatora, zmieniając stany rejestrów i licznik rozkazów (PC). [2, 4, 5, 6]
Kod jest dostosowany do systemów Linux (w tym Kubuntu), wymusza czytelną czcionkę systemową i ciasne, estetyczne układanie bloków danych.
von_neumann_cycle.py:
import random
from PIL import Image, ImageDraw, ImageFont
def generate_von_neumann_gif():
frames = []
width, height = 650, 450
bg_color = "#0A0F1D" # Ciemnogranatowe tło laboratoryjne
box_color = "#1E293B" # Kolor modułów (szaro-niebieski)
text_color = "#E2E8F0" # Jasny tekst główny
accent_fetch = "#38BDF8" # Błękitny dla fazy pobierania (Fetch)
accent_exec = "#22C55E" # Neonowa zieleń dla fazy wykonania (Execute)
# Próba załadowania czcionki stałoszerokościowej dla Kubuntu
try:
font = ImageFont.truetype("NimbusMonoPS-Regular.otf", 13)
font_bold = ImageFont.truetype("NimbusMonoPS-Regular.otf", 14)
except IOError:
try:
font = ImageFont.truetype("monospace", 13)
font_bold = ImageFont.truetype("monospace", 14)
except IOError:
font = ImageFont.load_default()
font_bold = font
# Historyczne rejestry maszyny IAS von Neumanna
pc = 100 # Program Counter (Licznik rozkazów)
ac = 0 # Accumulator (Akumulator wynikowy)
# 8 przykładowych kroków programu matematycznego
operations = [
("FETCH", "LOAD M(500)", "Pobieranie instrukcji spod adresu 500"),
("EXECUTE", "AC <- M(500)", "Załadowanie wartości z pamięci do Akumulatora"),
("FETCH", "ADD M(501)", "Pobieranie rozkazu dodawania"),
("EXECUTE", "AC <- AC + M(501)", "ALU: Dodawanie zawartości adresu 501 do AC"),
("FETCH", "SUB M(502)", "Pobieranie rozkazu odejmowania"),
("EXECUTE", "AC <- AC - M(502)", "ALU: Odejmowanie wartości 502 od AC"),
("FETCH", "STOR M(503)", "Pobieranie rozkazu zapisu"),
("EXECUTE", "M(503) <- AC", "Zapisanie końcowego wyniku z AC do pamięci")
]
print("Generowanie klatek prezentacji architektury IAS...")
for idx, (phase, instr, desc) in enumerate(operations):
img = Image.new("RGB", (width, height), color=bg_color)
draw = ImageDraw.Draw(img)
# Kolorystyka zależna od fazy cyklu procesora
current_accent = accent_fetch if phase == "FETCH" else accent_exec
# 1. Nagłówek okna prezentacyjnego
draw.text((25, 20), "PRINCETON IAS MACHINE — CYKL MASZYNOWY VON NEUMANNA", fill="#94A3B8", font=font_bold)
draw.line([25, 45, width-25, 45], fill="#334155", width=2)
# 2. Główny Monitor Stanu Procesora (Środek ekranu)
draw.rectangle([25, 65, width-25, 145], fill=box_color, outline=current_accent, width=2)
draw.text((45, 80), f"FAZA CYKLU: {phase}", fill=current_accent, font=font_bold)
draw.text((45, 100), f"INSTRUKCJA: {instr}", fill="#FFFFFF", font=font_bold)
draw.text((45, 120), f"OPERACJA: {desc}", fill="#94A3B8", font=font)
# 3. Architektura blokowa (Wizualizacja rejestrów na dole)
# Blok A: JEDNOSTKA STERUJĄCA (Control Unit)
draw.rectangle([25, 175, 300, 310], fill="#0F172A", outline="#475569", width=1)
draw.text((40, 185), "JEDNOSTKA STERUJĄCA (CU)", fill="#38BDF8", font=font_bold)
draw.text((40, 215), f"PC (Licznik Rozkazów): {pc}", fill=text_color, font=font)
draw.text((40, 245), f"IR (Rejestr Rozkazów): {instr.split()[0]}", fill=text_color, font=font)
draw.text((40, 275), f"MAR (Adres Pamięci): {instr.split()[-1] if '(' in instr else '---'}", fill=text_color, font=font)
# Blok B: JEDNOSTKA ARYTMETYCZNA (ALU)
draw.rectangle([345, 175, 625, 310], fill="#0F172A", outline="#475569", width=1)
draw.text((360, 185), "ARYTMOMETR (ALU)", fill="#22C55E", font=font_bold)
draw.text((360, 215), f"AC (Akumulator): {ac}", fill="#FFFFFF" if phase == "EXECUTE" else text_color, font=font_bold)
draw.text((360, 245), "MQ (Mnożnik/Iloraz): 0", fill=text_color, font=font)
draw.text((360, 275), "Status Flag: [OK]", fill="#94A3B8", font=font)
# 4. Wspólna pamięć RAM na samym dole (Sedno architektury von Neumanna!)
draw.rectangle([25, 340, width-25, 415], fill="#1E293B", outline="#F59E0B", width=1)
draw.text((45, 350), "WSPÓLNA PAMIĘĆ OPERACYJNA (Dane i Program w jednym miejscu)", fill="#F59E0B", font=font_bold)
# Pogląd pamięci RAM (Dane zmieniają się symulacyjnie)
ram_text = "Adres: [100: Instrukcje] [500: Dane X=42] [501: Dane Y=12] [503: Wynik]"
draw.text((45, 380), ram_text, fill="#94A3B8", font=font)
# Aktualizacja zmiennych procesora na potrzeby kolejnej klatki
if phase == "EXECUTE":
pc += 1 # Zwiększ licznik rozkazów po wykonaniu pełnego cyklu
if "LOAD" in instr: ac = 42
elif "ADD" in instr: ac = 54
elif "SUB" in instr: ac = 40
frames.append(img)
# ZAPIS DO PLIKU GIF (Poprawione wywołanie na pierwszym elemencie listy)
print("Kompilowanie pliku von_neumann_cycle.gif...")
frames[0].save(
"von_neumann_cycle.gif",
save_all=True,
append_images=frames[1:],
duration=2200, # 2.2 sekundy na klatkę, aby studenci nadążyli przeczytać opis operacji
loop=0 # Nieskończona pętla w pliku GIF
)
print("Sukces! Wygenerowano plik: von_neumann_cycle.gif")
if __name__ == "__main__":
generate_von_neumann_gif()
Co ta animacja idealnie pokazuje na wykładzie?
1. Jednolita pamięć (RAM): Na dole znajduje się jeden pomarańczowy moduł pamięci. Możesz wskazać palcem, że procesor sięga tam zarówno po rozkaz (FETCH), jak i po zmienną liczbową (EXECUTE). [4, 9, 10]
2. Praca rejestrów: Idealnie widać, jak licznik PC rośnie sekwencyjnie o 1 po zakończeniu fazy wykonawczej, kierując maszynę do kolejnego zadania. [6, 7, 10]
3. Rola Akumulatora: Wartość w rejestrze AC (Akumulatorze) zmienia się dynamicznie w locie z 0 na 42, potem na 54 i 40 – dokładnie tak, jak opisywał to von Neumann w swoim raporcie z 1945 roku dotyczącym komputera EDVAC. [6, 11]
Czy ten schemat działania rejestrów dobrze uzupełni część prezentacji poświęconą budowie procesorów, czy chcesz dodać do symulacji konkretną instrukcję skoku warunkowego (JUMP), która była kluczowa w projektach von Neumanna?
[1] https://lo1.lebork.pl
[2] https://en.wikipedia.org
[3] https://pl.wikipedia.org
[4] https://www.101computing.net
[5] https://prezi.com
[6] https://www.scribd.com
[7] https://esezam.okno.pw.edu.pl
[8] https://www.ic.unicamp.br
[9] https://natalialokaj.wordpress.com
[10] https://transpluton.files.wordpress.com
[11] https://prezi.com
Aby zamienić ten skrypt generujący plik GIF w żywy program, który bez przerwy wypisuje cykl pracy procesora na ekran Twojego terminala (w dół konsoli), musisz usunąć całą logikę zapisywania obrazów (PIL/Pillow) i zastąpić ją standardową funkcją print() oraz pętlą while True.
Dodatkowo, aby uzyskać efekt ciągłości, losujemy instrukcje w nieskończoność i dodajemy opóźnienie czasowe (time.sleep), żeby tekst nie przewijał się za szybko.
Oto kompletny kod, który po prostu wklejasz do pliku (np. ias_live_stream.py) i uruchamiasz w terminalu Kubuntu:
import time
import random
class EnigmaMachineConsole:
"""Uproszczona logika Enigmy, aby generować dynamiczne zmiany w tle"""
def __init__(self):
self.r_pos = [0, 0, 0]
def step_and_get_pos(self):
self.r_pos[2] = (self.r_pos[2] + 1) % 26
if self.r_pos[2] == 0:
self.r_pos[1] = (self.r_pos[1] + 1) % 26
if self.r_pos[1] == 0:
self.r_pos[0] = (self.r_pos[0] + 1) % 26
return f"[{chr(self.r_pos[0]+65)}][{chr(self.r_pos[1]+65)}][{chr(self.r_pos[2]+65)}]"
def run_live_ias_stream():
enigma = EnigmaMachineConsole()
# Przykładowe historyczne komendy architektury IAS von Neumanna
commands = [
("LOAD M(500)", "Załadowanie wartości X z pamięci RAM do Akumulatora (AC)"),
("ADD M(501)", "ALU: Dodanie wartości Y z RAM do rejestru Akumulatora"),
("SUB M(502)", "ALU: Odejęcie wartości Z spod adresu 502 od Akumulatora"),
("STOR M(503)", "Zapisanie końcowego wyniku z Akumulatora z powrotem do RAM"),
("JUMP M(120)", "Skok warunkowy: Przejście do wykonywania instrukcji pod adresem 120"),
("LSH", "ALU: Przesunięcie bitowe zawartości Akumulatora w lewo (mnożenie x2)"),
]
pc = 100 # Licznik rozkazów (Program Counter)
ac = random.randint(10, 99) # Startowa losowa wartość w akumulatorze
step = 1
print("\033[H\033[J") # Czyszczenie ekranu terminala przed startem
print("=========================================================================")
print(" PRINCETON IAS MACHINE — NIEPRZERWANY STRUMIEŃ CYKLU VON NEUMANNA")
print("=========================================================================\n")
time.sleep(1.0)
try:
while True:
# Losujemy operację z bazy historycznych komend IAS
instr, desc = random.choice(commands)
# --- FAZA 1: FETCH (POBIERANIE) ---
# Animacja Enigmy w tle symuluje ciągłe kryptograficzne generowanie/przetwarzanie danych przez system
enigma_pos = enigma.step_and_get_pos()
print(f"[{step:04d}] [FETCH] PC: {pc} | BĘBNY ENIGMY: {enigma_pos} -> Pobieranie: {instr}")
time.sleep(0.7) # Czas na przeczytanie fazy Fetch
# --- FAZA 2: EXECUTE (WYKONANIE) ---
# Symulujemy zmiany w rejestrze Akumulatora w zależności od wylosowanej komendy
if "LOAD" in instr: ac = random.randint(10, 99)
elif "ADD" in instr: ac += random.randint(1, 20)
elif "SUB" in instr: ac -= random.randint(1, 10)
elif "LSH" in instr: ac *= 2
print(f"[{step:04d}] [EXECUTE] AC: {ac:03d} | OPERACJA: {desc} -> [OK]")
print("-" * 73) # Kreska oddzielająca cykle maszynowe
# Przygotowanie zmiennych pod kolejną iterację pętli
pc += 1
step += 1
time.sleep(1.2) # Czas na przeczytanie wyniku przed kolejnym krokiem
except KeyboardInterrupt:
print("\n\nPrzerwano transmisję strumienia. Procesor zatrzymany (HALT).")
if __name__ == "__main__":
run_live_ias_stream()
Co się zmieniło w działaniu:
1. Pętla while True: Program nigdy sam się nie skończy. Będzie produkował logi linia po linii tak długo, aż nie wyłączysz go skrótem Ctrl + C.
2. Efekt "scrolling terminal": Tekst nie nadpisuje starych klatek. Przybywa go u dołu ekranu, przesuwając całą historię w górę, co daje doskonały, dynamiczny efekt pracującego komputera/serwera w tle.
3. Zbalansowane opóźnienia (time.sleep): Faza pobierania (Fetch) pojawia się najpierw, a po niespełna sekundzie pod nią wskakuje wynik wykonania (Execute). Cały cykl zamyka się w około 2 sekundach – idealne tempo, aby rzucić na to okiem z widowni podczas Twojego wykładu.
Czy taki format tekstu płynącego na żywo przez ekran terminala zamknie przygotowania techniczne do Twojego wystąpienia?
Oto kompletny kod dla maszyny IAS von Neumanna, który działa na żywo w terminalu Kubuntu i wykorzystuje dokładnie ten sam mechanizm odświeżania stałych pól, który zaprojektowałem dla pliku GIF.
Program co sekundę czyści ekran (\033[H), rysuje estetyczne, tekstowe ramki architektury procesora, a następnie aktualizuje wartości rejestrów (PC, AC, IR, MAR) oraz fazę cyklu rozkazowego (FETCH / EXECUTE).
Kod symulatora IAS na żywo w konsoli (Python 3)
Zapisz kod jako plik np. ias_terminal_live.py i uruchom w konsoli. Działa w nieskończonej pętli (wyjście przez Ctrl + C).
import time
import random
import sys
def run_ias_live_interface():
# Historyczna baza rozkazów maszyny IAS von Neumanna
operations = [
("FETCH", "LOAD M(500)", "Pobieranie instrukcji spod adresu 500"),
("EXECUTE", "AC <- M(500)", "Załadowanie wartości z pamięci do Akumulatora"),
("FETCH", "ADD M(501)", "Pobieranie rozkazu dodawania"),
("EXECUTE", "AC <- AC + M(501)", "ALU: Dodawanie zawartości adresu 501 do AC"),
("FETCH", "SUB M(502)", "Pobieranie rozkazu odejmowania"),
("EXECUTE", "AC <- AC - M(502)", "ALU: Odejmowanie wartości 502 od AC"),
("FETCH", "STOR M(503)", "Pobieranie rozkazu zapisu"),
("EXECUTE", "M(503) <- AC", "Zapisanie końcowego wyniku z AC do pamięci")
]
pc = 100 # Program Counter
ac = 0 # Accumulator
step_idx = 0
try:
while True:
# Pobranie aktualnego kroku cyklu (zawijanie pętli po 8 krokach)
phase, instr, desc = operations[step_idx % len(operations)]
# Pobranie parametrów do rejestrów instrukcji
ir_val = instr.split()[0]
mar_val = instr.split()[-1] if '(' in instr else "---"
# Dynamiczna zmiana akumulatora i licznika w fazie EXECUTE
if phase == "EXECUTE" and (step_idx % len(operations) == 1): ac = 42
elif phase == "EXECUTE" and (step_idx % len(operations) == 3): ac = 54
elif phase == "EXECUTE" and (step_idx % len(operations) == 5): ac = 40
if phase == "EXECUTE":
pc_display = pc
pc += 1
else:
pc_display = pc
# KOD ANSI: \033[H ustawia kursor na samej górze (odświeżanie bez migania)
sys.stdout.write("\033[H")
# Budowanie widoku identycznego jak w wersji GIF
output = []
output.append("=====================================================================")
output.append(" PRINCETON IAS MACHINE — CYKL MASZYNOWY VON NEUMANNA (LIVE)")
output.append("=====================================================================\n")
output.append(f" FAZA CYKLU: {phase}")
output.append(f" INSTRUKCJA: {instr}")
output.append(f" OPERACJA: {desc}\n")
output.append("+-----------------------------------+-------------------------------+")
output.append("| JEDNOSTKA STERUJĄCA (CU) | ARYTMOMETR (ALU) |")
output.append("+-----------------------------------+-------------------------------+")
output.append(f"| PC (Licznik Rozkazów): {pc_display:<10} | AC (Akumulator): {ac:<9} |")
output.append(f"| IR (Rejestr Rozkazów): {ir_val:<10} | MQ (Mnożnik/Iloraz): 0 |")
output.append(f"| MAR (Adres Pamięci): {mar_val:<10} | Status Flag: [OK] |")
output.append("+-----------------------------------+--------------------------------+")
output.append("| WSPÓLNA PAMIĘĆ OPERACYJNA RAM |")
output.append(f"| Adresy: [100: Kod] [500: X=42] [501: Y=12] [503: Wynik={ac:<3}] |")
output.append("+--------------------------------------------------------------------+\n")
output.append("Naciśnij Ctrl + C, aby zatrzymać symulację procesora.")
# Jednorazowy zrzut całego interfejsu na ekran
sys.stdout.write("\n".join(output))
sys.stdout.flush()
# Czas wyświetlania jednej klatki (2 sekundy dla płynnego czytania)
time.sleep(2.0)
step_idx += 1
# Reset symulacji po pełnym wykonaniu programu dla ciągłości tła
if step_idx % len(operations) == 0:
pc = 100
ac = 0
except KeyboardInterrupt:
print("\n\n[HALT] Procesor został zatrzymany sygnałem przerwaniowym.")
if __name__ == "__main__":
# Czyszczenie ekranu przed pierwszym rysowaniem
print("\033[H\033[J", end="")
run_ias_live_interface()
Dlaczego to rozwiązanie działa dokładnie tak jak GIF?
- Wyrównane tabele ASCII: Rejestry procesora są zamknięte w sztywnej ramce tekstowej zbudowanej ze znaków +, - oraz |. Liczby są dynamicznie wyrównywane do lewej za pomocą formatowania {ac:<9}, dzięki czemu ramka nigdy się nie rozjeżdża.
- Brak efektu skrolowania: Zamiast dopisywać linie w dół i zaśmiecać konsolę, sekwencja \033[H co krok przestawia kursor na pozycję (0,0). Dane w tabeli zmieniają się „w miejscu”, dając czysty, pulpitowy efekt aplikacji monitorującej stan komputera.
- Bezpieczeństwo czcionki: Ponieważ to czysty tekst wysyłany bezpośrednio do strumienia wyjściowego systemu operacyjnego, Kubuntu użyje profilu Twojego domyślnego terminala (np. Konsole), zachowując idealne proporcje monospace.