Wikipedia - Benutzerbeiträge [de]

RISC-V

2024-09-22T12:02:30Z

SimDoc: Didaktische Erläuterung zur Mikrocodesimulation

[[Datei:RISC-V-logo.svg|mini|Logo]]
[[Datei:Yunsup Lee holding RISC V prototype chip.jpg|mini|Prototyp eines RISC-V Mikroprozessors aus dem Jahr 2013]]
'''RISC-V''', offizielle Aussprache in Englisch: „{{lang|en|risc-five}}“<ref>{{Literatur |Titel=RISC-V ISA - RISC-V Foundation |Sammelwerk=RISC-V Foundation |Datum= |Online=https://riscv.org/risc-v-isa/ |Abruf=2018-02-03| Sprache=en-US}}</ref> [{{IPA|rɪsk faɪv}}], ist eine [[Befehlssatzarchitektur]] (engl. ''instruction set architecture'', ISA), die sich auf das Designprinzip des [[Reduced Instruction Set Computer]]s (RISC) stützt. Es ist ein [[offener Standard]], welcher der freien [[BSD-Lizenz]] unterliegt. Das bedeutet, dass RISC-V nicht patentiert ist und frei verwendet werden darf. Somit ist es jedem erlaubt, RISC-V Mikroprozessoren zu entwerfen, herzustellen, weiterzuentwickeln und zu verkaufen ([[Open-Source-Hardware]]).<ref>{{Literatur |Titel=FAQ - RISC-V Foundation |Sammelwerk=RISC-V Foundation |Datum= |Online=https://riscv.org/about/faq/ |Abruf=2023-12-22 |Sprache=en-US }}</ref> Zahlreiche Unternehmen bieten RISC-V-Hardware an oder haben diese angekündigt.

Der RISC-V Befehlssatz wurde für eine Vielzahl von Anwendungsfällen entworfen. Er hat eine variable [[Datenwort]]breite und ist erweiterbar, so dass jederzeit mehr Kodierungsbits hinzugefügt werden können. Er unterstützt drei Datenwortbreiten: 32, 64 und 128 Bit und eine Auswahl an Unterbefehlssätzen. Die Definitionen jedes Unterbefehlssatzes variieren geringfügig zwischen den drei Wortbreiten. Die Unterbefehlssätze unterstützen kompakte [[Eingebettetes System|eingebettete Systeme]], [[Personal Computer|persönliche Rechner]], [[Supercomputer|Hochleistungsrechner]] mit [[Vektorprozessor]]en und [[Parallelrechner]].

Der Befehlssatzraum für den auf 128 Bit gedehnten Befehlssatz wurde reserviert, weil 60 Jahre Industrieerfahrung gezeigt haben, dass die meisten nicht wieder gut zu machenden Fehler in der Gestaltung von Befehlssätzen durch fehlenden Speicheradressraum verursacht wurden. Noch im Jahr 2016 blieb der 128-Bit-Teil des Befehlssatzes absichtlich undefiniert, da bisher wenig Erfahrung mit solch großen Speichersystemen besteht. Es gibt Vorschläge, Instruktionen mit einer variablen Breite bis zu 864 Bit zu implementieren.<ref>{{Internetquelle |autor=Wolf, Clifford |url=http://svn.clifford.at/handicraft/2019/rvlonginsn/proposal_1.txt |archiv-url=https://web.archive.org/web/20191020070636/http://svn.clifford.at/handicraft/2019/rvlonginsn/proposal_1.txt |archiv-datum=2019-10-20 |titel=Alternative proposal for instruction length encoding |abruf=2019-10-20}}</ref>

Das Projekt begann 2010 an der [[University of California, Berkeley]] unter der Leitung von [[Krste Asanovic]] und [[David A. Patterson]] und wird bereits von Hard- und Softwareentwicklern weltweit mitentwickelt und gefördert.<ref>{{Literatur |Titel=Contributors - RISC-V Foundation |Sammelwerk=RISC-V Foundation |Datum= |Online=https://riscv.org/contributors/ |Abruf=2018-02-03 }}</ref> Anders als andere akademische Entwürfe, die üblicherweise auf einfache Erläuterung optimiert sind (vgl. [[Mikrocodesimulator]] [[MikroSim]]), wurde der RISC-V-Befehlssatz für die praktische Anwendung in Rechnern entworfen. Er besitzt Eigenschaften, die die Rechnergeschwindigkeit erhöhen, aber trotzdem die Kosten und den Energieverbrauch senken. Dies schließt eine [[Load/Store-Architektur]] ein, sowie Bit-Muster, um die Multiplexer in einer CPU zu vereinfachen, vereinfachte Standard-basierte Gleitkommazahlen, einen architekturneutralen Entwurf und das Setzen des [[Byte-Reihenfolge|höchstwertigen Bits]] an eine festgelegte Position, um die [[Zweierkomplement#Vorzeichenerweiterung|Vorzeichenerweiterung]] zu beschleunigen. Vorzeichenerweiterung wird häufig als kritisch eingestuft.
Im Jahre 2019 wurde die Version 2.2 des [[Ring (CPU)|Userspace]]-ISA<ref>{{internetquelle| url=https://github.com/riscv/riscv-isa-manual/releases/download/Ratified-IMAFDQC/riscv-spec-20191213.pdf| titel=The RISC-V Instruction Set Manual, Volume I: User-Level ISA, Document Version 20191213| autor=Andrew Waterman, Krste Asanović, RISC-V Foundation| datum=2019-12-13| format=pdf| sprache=en| abruf=2023-07-18}}</ref> und im Jahre 2021 die Version 1.12 des privilegierten ISA<ref name=":0">{{internetquelle| url=https://github.com/riscv/riscv-isa-manual/releases/download/Priv-v1.12/riscv-privileged-20211203.pdf| titel=The RISC-V Instruction Set Manual, Volume II: Privileged Architecture, Document Version 20211203| autor=Andrew Waterman, Krste Asanović, John Hauser, RISC-V International| datum=2021-12-04| format=pdf| sprache=en| abruf=2023-07-18}}</ref> festgelegt und ermöglichen es Software- und Hardwareherstellern, diesen zu nutzen oder zu implementieren. Eine Fehlersuch-Spezifikation ist in der Spezifikation der privilegierten ISA enthalten.

== Architektur ==
Der RISC-V-Befehlssatz steht in der Tradition der [[RISC]]-Prozessoren, die sich auf möglichst wenige, einfach zu dekodierende Maschinenbefehle konzentrieren. Dementsprechend hat der einfachste RISC-V-Befehlssatz (RV32I) nur 40 Befehle.

RISC-V hat in allen Varianten eine Wortgröße von 32 bit. Demnach sind alle regulären standardisierten Befehle 32 bit groß, und die kleinstmögliche Registergröße ist 32 bit. Für einige Befehle gibt es in der C-Erweiterung (siehe unten) alternative Kodierungen, die nur 16 bit (Halbwort) groß sind, allerdings dasselbe Verhalten aufweisen wie der entsprechende 32-bit-Befehl. Die Größe eines Maschinenbefehls kann an den untersten Bit des Befehls abgelesen werden, und Maschinenbefehle mit 64 und 128 bit Größe sind hier bereits vorgesehen. Ist die C-Erweiterung nicht implementiert, müssen Befehle an 4-Byte-Grenzen [[Speicherausrichtung|ausgerichtet]] sein, andernfalls können es auch 2-Byte-Grenzen sein (selbst für 32-bit-Befehle).

RISC-V ist eine [[Little-Endian]]-Architektur. Befehle werden immer in Little-Endian-Reihenfolge gelesen; daher auch die Kodierung der Befehlsgröße in den untersten Befehlsbits, die sich immer im ersten gelesenen Byte befinden. Falls die Implementierung dies unterstützt, kann nur für Datenzugriffe im Hauptspeicher auf Big-Endian umgeschaltet werden.

=== Architekturen und Erweiterungen ===
RISC-V ist nicht eine einzige Architektur, sondern eine ganze Familie an Architekturen, die modular aufeinander aufbauen. So gibt es die drei Grundarchitekturen namens RV32I, RV64I und RV128I, die entsprechend der Zahl im Namen eine Register- und Speicherbreite von 32, 64 bzw. 128 bit besitzen. Auch wenn streng genommen RV64I keine einfache Erweiterung von RV32I ist, werden alle existierenden Befehle mit neuer Bedeutung übernommen; der ADD-Befehl addiert beispielsweise nun statt zweier 32-bit Zahlen zwei 64-bit Zahlen. Die Grundarchitekturen enthalten entsprechend des „I“ im Namen nur ''Integer''-Befehle, d. h. Befehle, die mit Ganzzahlen rechnen. Dazu kommen andere, fast immer benötigte Befehle wie bedingte und unbedingte Sprungbefehle, Speicherzugriffsbefehle und [[Software-Interrupt]]-Befehle. Alle weiteren Funktionalitäten sind in standardisierte Befehlssatzerweiterungen zusammengefasst, die jeweils eine 32-bit, 64-bit und 128-bit-Version besitzen. Wichtige Erweiterungen und ihre Namen sind:

* M für Ganzzahl-Multiplikation und -Division
* A für [[Atomare Operation|atomare Speicheroperationen]] in Multiprozessorsystemen
* F, D und Q für [[Gleitkommaoperation]]en nach [[IEEE 754]]: binary32, binary64 bzw. binary128
* Zicsr für Control and Status Registers (CSRs) (siehe unten)
* C für komprimierte Befehle, das sind 16-bit-Kodierungen häufig verwendeter Befehle, die somit den Speicherverbrauch reduzieren.

Es ist explizit vorgesehen, dass proprietäre bzw. Drittanbieter-Erweiterungen für RISC-V verfasst werden, die einen mit X beginnenden Namen führen. Beispiele dafür sind XTheadBb, XTheadSync oder XVentanaCondOps.<ref>{{Internetquelle |url=https://sourceware.org/binutils/docs/as/RISC_002dV_002dCustomExts.html |titel=RISC-V-CustomExts (Using as) |abruf=2023-12-12}}</ref>

Verfügt eine RISC-V-Implementierung nun über eine bestimmte Sammlung an Erweiterungen, so kann diese entsprechend der Kurznamen kompakt bezeichnet werden, beispielsweise RV64IMCZicsr für einen Prozessor, der über die 64-bit-Basisarchitektur mit Ganzzahlmultiplikationen, komprimierten Befehlen und CSR-Unterstützung verfügt. Manche Erweiterungen hängen wiederum von anderen ab; so ist die Unterstützung von 64-bit-Gleitkommazahlen (D) nur gleichzeitig mit CSRs (Zicsr) und 32-bit-Gleitkommazahlen (F) möglich. Für eine CPU, die ein Endbenutzer-Betriebssystem ausführen kann, werden eine ganze Reihe an Erweiterungen benötigt, die unter der Pseudo-Erweiterung G (''general purpose'') zusammengefasst werden. RV64G bedeutet demnach eigentlich RV64IMAFDZicsr_Zifencei, also die Basisarchitektur inklusive sieben Erweiterungen.

=== Basisarchitektur ===
RISC-V besitzt 32 Register, die ganze Zahlen enthalten. Die Basisarchitektur bestimmt deren Größe; so hat RV32 eben 32-bit-Register und RV64 64-bit-Register. Die Register werden mit den Architekturnamen x0 bis x31 bezeichnet. Dabei ist x0 ein besonderes Register, da es beim Lesen immer 0 enthält und alle Schreibvorgänge auf x0 ignoriert werden. Dies wird genutzt, um verschiedene Funktionen ohne zusätzliche Befehle möglich zu machen:<syntaxhighlight lang="asm">
# Subtrahiert x6 von x0, d.h. negiert x6
sub x5, x0, x6
# Prüft, ob x0 kleiner als x13 ist, d.h. ob x13 größer als 0 ist
slt x2, x0, x13
# Speichert die Addition von 0 und x0 in x0; kanonisches NOP
addi x0, x0, 0
</syntaxhighlight>Viele dieser Funktionen sind in diversen Assembler-Pseudobefehlen verfügbar; für die drei Befehle oben wären es <code>neg</code>, <code>sgtz</code> bzw. <code>nop</code>.

Rechenbefehle verfügen immer über drei Operanden: zwei Quellregister <code>rs1</code> und <code>rs2</code> und ein Zielregister <code>rd</code>. Anders als bei anderen Architekturen ist das erste Quellregister nicht automatisch auch das Zielregister, wobei es natürlich möglich ist, dasselbe Register für Quelle und Ziel anzugeben. Befehle mit konstanten Operanden, sogenannte Immediate-Befehle, ersetzen <code>rs2</code> durch eine Konstante, die im Befehl selbst enthalten ist. Einige Beispiele für Rechenbefehle:<syntaxhighlight lang="asm">
# Addiert x0 (0) und 42 und speichert das Ergebnis in x7
# d.h. lädt die Konstante 42 in x7
addi x7, x0, 42
# Konstante 10 wird in x6 gespeichert
addi x6, x0, 10
# Subtrahiert x7 von x6 und speichert das Ergebnis in x5
sub x5, x6, x7
# Exklusives Oder mit Immediate
xori x4, x5, 0x1111
# Arithmetische Bitverschiebung nach rechts
sra x8, x4, x5
# Multipliziert x5 mit x4 und speichert das Ergebnis in x10
mul x10, x5, x4
</syntaxhighlight>

==== Konstanten, LUI und AUIPC ====
Gewöhnliche Immediate-Befehle können aufgrund der Befehlskodierung ausschließlich 12-bit-Konstanten enthalten. Je nachdem, ob die Konstante vorzeichenlos oder vorzeichenbehaftet ist, bedeutet dies einen Wertebereich von 0 bis 4096 bzw. −2048 bis 2047. Um auch größere Konstanten kodieren zu können, gibt es den Befehl ''Load Upper Immediate'' (<code>lui</code>). <code>lui</code> lädt eine 32-bit-Konstante, deren obere 20 bit dem Immediate entstammen und deren untere 12 bit auf 0 gesetzt werden. Mittels einer darauffolgenden Addition kann so in zwei Befehlen jede 32-Bit-Zahl geladen werden:
<syntaxhighlight lang="asm">
# Die Zahl 987654321 (0x3ADE6'8B1) soll in Register x20 geladen werden.

# Lade in x20 die Konstante 0x3ADE6'000,
# Das 20-bit-Immediate-Argument wird in Bit 31...12 geschrieben, Bit 11...0 werden genullt
lui x20, 0x3ADE6

# Setzen der unteren 12 bit
addi x20, x20, 0x8B1

# Verbreitete Assembler unterstützen den Makrobefehl li (load immediate)
# welcher je nach Konstante 1 oder 2 Befehle erzeugt:
li x20, 0x3ADE68B1

</syntaxhighlight>
Der Befehl ''Add Upper Immediate to Program Counter'' (<code>auipc</code>) addiert einen solchen 20-Bit-Immediate stattdessen zum aktuellen [[Befehlszähler|Programmzähler]] (''Program Counter''), womit effizient Speicheradressen in der Nähe des Programmcodes abgerufen werden können und der Code [[Position-independent Code|positionsunabhängig]] wird.

==== Speicherzugriffe ====
RISC-V hat als [[Load/Store-Architektur]] keine Befehle, die direkt auf Daten im Speicher Rechenoperationen durchführen können. Eine Ausnahme hiervon bilden die atomaren Befehle aus der A-Erweiterung, die solche Funktionalität zur Prozessorsynchronisierung benötigen (<code>amoadd</code>, <code>amoor</code>, <code>amoswap</code> etc.). Für reguläre Speicherzugriffe ist nur ein einfaches Laden oder Speichern vom/zum Hauptspeicher möglich, und der Addressierungsmodus ist immer Register+Konstante. Beispielsweise kann das Register die Startadresse einer Struktur enthalten und die Konstante den Offset eines Felds in der Struktur.<syntaxhighlight lang="asm">
# Lade Byte von Adresse 0x40
lb x11, 0x40(x0)
# Lade erstes Wort auf dem Stack (x2 ist der Stack Pointer)
lw x12, 4(x2)
# Lade Halbwort (16 bit) ohne Vorzeichenerweiterung
lhu x13, 2(x2)

# Speichere Doppelwort (nur RV64 und RV128)
sd x13, 8(x2)
# Speichere Wort ohne Vorzeichenerweiterung (nur RV64 und RV128)
swu x12, 0(x2)
</syntaxhighlight>Speicherzugriffe müssen [[Speicherausrichtung|ausgerichtet]] sein, z. B. Wortzugriffe auf Vielfache von 4 Byte und Doppelwortzugriffe auf 8 Byte. Eine Implementierung kann auch unausgerichtete Speicherzugriffe unterstützen, dies ist jedoch in der Regel nicht der Fall und wird eventuell in der Firmware emuliert (''fast trap and emulate'').

==== Kontrollfluss ====
RISC-V besitzt anders als die meisten heutzutage verbreiteten Architekturen kein [[Statusregister]] und keine Flags. Kontrollflussentscheidungen werden immer auf der Basis eines konkreten Vergleichs durchgeführt, zum Beispiel:<syntaxhighlight lang="asm">
# Springe falls x4 < x5 (ganze Zahlen)
blt x4, x5, label1
# Springe falls x7 >= x9 (natürliche Zahlen)
bgeu x7, x9, label2
# Springe falls x1 = 0 (Pseudobefehl beqz)
beq x1, x0, label3
</syntaxhighlight>Das Sprungziel wird im Maschinenbefehl als Offset vom aktuellen Befehl angegeben und kann bis zu ±4KiB betragen.

Für bedingungslose Sprünge, Prozeduraufruf und Rückkehr aus einer Prozedur dienen ''Jump And Link'' (<code>jal</code>) und ''Jump And Link Register'' (<code>jalr</code>). <code>jal</code> verwendet ein Offset wie die bedingten Branch-Befehle, wobei dank 20-bit-Offset jetzt Sprünge ±1MiB möglich sind. <code>jalr</code> benutzt ein kleineres Offset addiert zu einem Register und kann somit auf den gesamten Speicherbereich springen. Beide Befehle speichern die Adresse des folgenden Befehls im Zielregister, was später einen Rücksprung ermöglicht.<syntaxhighlight lang="asm">
# Sprung ohne Speichern der Rücksprungadresse (Pseudobefehl j)
jal x0, label1
# Rücksprungadresse wird im Return-Address-Register x1 gespeichert (Pseudobefehl call)
jal x1, my_procedure
# Sprung zur Return-Adresse aus x1 (Pseudobefehl ret)
jalr x0, x1, 0
</syntaxhighlight>

=== Gleitkommazahlen ===
RISC-V unterstützt mit den F-, D-, und Q-Erweiterungen [[Gleitkommazahl]]en nach dem [[IEEE 754-2008]]-Standard. 32 separate Register für Gleitkommazahlen sind verfügbar, f0-f31 genannt, wobei das Register f0 keine Sonderstellung wie x0 einnimmt. Je nach konkreter Erweiterung haben die Register eine Größe von 32, 64 oder 128 bit, und Gleitkommazahlen kleinerer Größe (bspw. 32-bit-Gleitkommazahlen auf einer Implementierung mit D-Unterstützung) werden mittels [[NaN-Packing]] „eingebettet“.

Gleitkommaoperationen haben analog zu den Ganzzahloperationen drei Operanden (zwei Quellregister und ein Zielregister). Ein [[Quadratwurzel]]<nowiki/>befehl existiert (<code>fsqrt</code>), aber beispielsweise kein [[Sinus und Kosinus|Sinus]] oder [[Kosinus]]. Es existieren direkte Speicherzugriffsbefehle, die Gleitkommaregister laden und speichern können. Es können sowohl Ganzzahlen in Gleitkommazahlen umgewandelt werden und zurück (<code>fcvt</code>), als auch die IEEE-754-Darstellung einer Kommazahl direkt aus einem Ganzzahlregister geladen oder in ein solches gespeichert werden (<code>fmv</code>). Mittels der ''Sign-Injection''-Befehle (<code>fsgnj</code>, <code>fsgnjx</code>, <code>fsgnjn</code>), die den Betrag des ersten Quellregisters und das Vorzeichen des zweiten Quellregisters kombinieren, können zusätzlich die Operationen Negation, Betrag und Register-Transfer (<code>fmv</code>) implementiert werden.

In den Basiserweiterungen F, D, und Q sind [[Fused multiply-add|Fused-Multiply-Add]]-Befehle enthalten (<code>fmadd</code>, <code>fmsub</code>, <code>fnmadd</code>, <code>fnmsub</code>), die als einzige Standardbefehle überhaupt vier Operanden (drei Quellregister) enthalten. Diese benötigen einen wesentlichen Anteil des 32-bit-Befehlsraums, sorgen aber in mathematischen Operationen und Multimediaanwendungen für einen deutlichen Geschwindigkeitsgewinn<ref>{{Literatur |Autor=R. K. Montoye, E. Hokenek, S. L. Runyon |Titel=Design of the IBM RISC System/6000 floating-point execution unit |Sammelwerk=IBM Journal of Research and Development |Band=34 |Nummer=1 |Datum=1990-01 |ISSN=0018-8646 |DOI=10.1147/rd.341.0059 |Seiten=59–70 |Online=http://ieeexplore.ieee.org/document/5389859/ |Abruf=2023-12-12}}</ref>.<syntaxhighlight lang="asm">
# Ausschnitt aus einer asinh-Implementierung
# Programmkonstante laden
auipc x12,0xfffbf
fld f11,-1154(x12)
# Diese Befehle nutzen alle dynamische Rundung
fmadd.d f5,f4,f5,f6
fmadd.d f5,f4,f5,f7
fmadd.d f5,f4,f5,f10
fmadd.d f5,f4,f5,f11
fld f6,-426(x10)
fmul.d f4,f4,f5
fmul.d f4,f3,f4
fmadd.d f2,f3,f2,f4
fmul.d f2,f2,f6
</syntaxhighlight>IEEE-754-Exceptions lösen keine Interrupts aus (was vom Standard auch erlaubt ist). Stattdessen dient das <code>fflags</code> (Gleitkomma-[[Flag (Informatik)|Flags]])-Kontrollregister zur Auflistung aller aufgetretenen Gleitkomma-Fehler.

Der Rundungsmodus kann in den meisten Befehlen fest angegeben werden und wird ansonsten dem <code>frm</code> (Gleitkomma-Rundungsmodus)-Kontrollregister entnommen:
{| class="wikitable sortable mw-collapsible mw-collapsed"
|+RISC-V-Gleitkomma-Rundungsmodi
|-
! Rundungsmodus
! Mnemonic
! Bedeutung
|-
| align="center" | 000 || <abbr title="Round to nearest, tie even">RNE</abbr> || Runde zur nächstgelegenen Zahl, [[Rundung#Symmetrisches Runden|bevorzuge gerade Zahlen]]
|-
| align="center" | 001 || <abbr title="Round to zero">RTZ</abbr> || Runde in Richtung ±0
|-
| align="center" | 010 || <abbr title="Round down">RDN</abbr> || Runde ab in Richtung −<big><big>∞</big></big>
|-
| align="center" | 011 || <abbr title="Round up" ">RUP</abbr> || Runde auf in Richtung +<big><big>∞</big></big>
|-
| align="center" | 100 || <abbr title="Round to nearest, tie maximum magnitude">RMM</abbr> || Runde zur nächstgelegenen Zahl, [[Rundung#Kaufmännisches Runden|bevorzuge größeren Betrag]]
|-
| align="center" | 111 || <abbr title="Dynamic">DYN</abbr> || nutze <code>frm</code>-Kontrollregister für Rundungsmodus
|}

=== Control and Status Registers (Zicsr) ===
Um das Verhalten des Prozessors und verschiedener Befehle zu steuern, verfügt ein RISC-V-Prozessor mit der Zicsr-Erweiterung über bis zu 4096 sogenannter ''Control and Status Register'', d. h. Kontroll- und Statusregister, abgekürzt CSRs. Die CSRs werden mit eigenen Befehlen wie <code>csrrw</code> und <code>csrrci</code> modifiziert, die in der Regel gleichzeitig ein CSR lesen und schreiben, außer es wird x0 als Operand genutzt. Abhängig vom Prozessormodus und der Implementierung sind manche CSRs nur lesbar, oder Schreibzugriffe werden ignoriert. Wichtige CSRs sind beispielsweise:

* IEEE 754 Exceptions (<code>fflags</code>) und Rundungsmodi (<code>frm</code>)
* Performance-Counter: Verstrichene Taktzyklen (<code>cycle</code>), Monotoner Zeitzähler beliebiger Auflösung (<code>time</code>), abgearbeitete Befehle (<code>instret</code>) und 29 weitere Zähler mit unspezifizierter Funktion

Der Großteil der CSRs wird für Systemfunktionalitäten benötigt und ist daher in üblichen Benutzeranwendungen nicht verfügbar. Dazu gehören beispielsweise:

* Interruptsteuerung für S-, H- oder M-Mode (<code>sstatus</code>, <code>sie</code>, <code>stvec</code>, ...)
* Informationen für den Interrupthandler (<code>sepc</code>/<code>mepc</code>, <code>scause</code>/<code>mcause</code>, <code>stval</code>/<code>mtval</code>, ...)
* Konfiguration der Physical Memory Protection (PMP) (<code>pmpcfg0</code>-<code>pmpcfg15</code>, <code>pmpaddr0</code>-<code>pmpaddr63</code>)
* Verfügbare RISC-V-Erweiterungen (<code>misa</code>)

=== ABI ===
Die [[Application Binary Interface|ABI]] für RISC-V wird, anders als bei vielen Architekturen, gemeinsam mit der ISA spezifiziert und standardisiert.<ref>{{Internetquelle |autor=Alex Bradbury, Andrew Burgess, Chih-Mao Chen, Zakk Chen, Kito Cheng, Nelson Chu, Michael Clark, Jessica Clarke, Palmer Dabbelt, Sam Elliott, Gonzalo Brito Gadeschi, Sebastian Huber, Roger Ferrer Ibanez, Quey-Liang Kao, Nick Knight, Luís Marques, Evandro Menezes, Max Nordlund, Stefan O’Rear, Konrad Schwarz, Fangrui Song, Hsiangkai Wang, Andrew Waterman, Jim Wilson |url=https://github.com/riscv-non-isa/riscv-elf-psabi-doc |titel=RISC-V ABIs Specification Version 1.0: Ratified |datum=2022-11 |format=PDF; 268 KB |sprache=en |abruf=2023-12-12}}</ref> Je nach Basisarchitektur und genauer Prozeduraufrufkonvention, besonders zur Behandlung von Gleitkommaparametern, gibt es verschiedene inkompatible ABIs, die wie die Architekturen mit Kürzeln wie LP64D, ILP32 oder ILP32E bezeichnet werden. Teil der standardisierten ABI ist auch die Spezifikation zur Verwendung des [[Executable and Linking Format|ELF]]-Binärformats für RISC-V.

Die ABI weist einigen Registern besondere Bedeutungen zu und teilt die übrigen Register in die Kategorien ''Saved'', ''Argument'' und ''Temporary'' ein. Jedes Register, ob Ganzzahl- oder Gleitkommaregister, erhält entsprechend einen ABI-Namen, der die Assemblerprogrammierung vereinfacht.
{| class="wikitable"
|+
!Register
!ABI- Name(n)
!Bezeichnung
!Erklärung
|-
|x0
|zero
|Zero
|Konstantes Nullregister (Lesen: Wert 0, Schreiben: kein Effekt)
|-
|x1
|ra
|Return address
|Rücksprungadresse; wird in Pseudobefehlen wie <code>ret</code> und <code>call</code> implizit genutzt.
|-
|x2
|sp
|Stack pointer
|[[Stapelzeiger]]. Einige Erweiterungen wie C besitzen spezialisierte Befehle hierfür.
|-
|x3
|gp
|Global pointer
|Zeiger auf die Liste globaler Programmsymbole.
|-
|x4
|tp
|Thread pointer
|Zeiger auf den [[Thread-local block|TLB]] des aktuellen Programmthreads, siehe [[Thread-local storage]].
|-
|x8
|fp
|Frame pointer
|Framezeiger, zeigt auf die Startadresse des aktuellen Stackframes. Optional; entspricht auch s0.
|-
|{{nowrap|x5…7, x28…31}}
|t0…6
|Temporary registers
|Register für temporäre Daten, die beim Prozeduraufruf nicht erhalten bleiben müssen.
|-
|x8…9, x18…27
|s0…11
|Callee-saved registers
|Register, die von aufgerufenen Prozeduren gesichert werden, falls sie diese benötigen.
|-
|x10…17
|a0…7
|Argument registers
|Register für die ersten 8 Prozedurargumente und Rückgabewerte.
|-
|f0…7, f28…31
|ft0…11
|Floating-point Temporary registers
|Temporäre Register für Gleitkommazahlen.
|-
|f8…9, f18…27
|fs0…11
|{{nowrap|Floating-point Callee-saved registers}}
|Gesicherte Register für Gleitkommazahlen.
|-
|f10…17
|fa0…7
|Floating-point Argument registers
|Register für die ersten 8 Gleitkomma-Argumente und -Rückgabewerte von Prozeduren.
|}

==== Prozeduraufruf (Calling Convention) ====
Bei einem Prozeduraufruf werden nur die gesicherten bzw. unveränderlichen Register wie s0-s11 oder gp erhalten. So viele Argumente wie möglich werden in den Argumentregistern übergeben, weitere Argumente kommen auf den Stack. Rückgabewerte werden genauso wie Argumente übergeben.

Prozeduraufrufe (mit Pseudobefehlen <code>ret</code> und <code>call</code>) interagieren nicht ohne weiteres mit dem Stack, was die manuelle Sicherung der Rücksprungadresse spätestens direkt vor einem weiteren Prozeduraufruf erfordert. In der Praxis werden Register nach aufsteigender Nummer auf dem Stack gesichert, sodass die Rücksprungadresse auf dem Stack ganz unten liegt. Führt eine Prozedur allerdings keinen weiteren Prozeduraufruf auf, so erübrigt sich auch die Sicherung der Rücksprungadresse.

Ein RISC-V-Stack wächst „nach unten“ (Richtung absteigender Adressen) und der Stapelzeiger zeigt immer auf den obersten in Verwendung befindlichen Speicher.<syntaxhighlight lang="asm">
# Beginn der asinh-Prozedur von oben
# Stack um zwei Doppelworte vergrößern...
addi x2, x2, -16
# ... damit zwei Register gesichert werden können.
sd x1, 8(x2) # Rücksprungadresse (diese Prozedur ruft noch andere Prozeduren auf)
sd x8, 0(x2) # Frame Pointer des Aufrufers
# Neuen Frame Pointer einrichten (entsprechend der Stackadresse beim Prozedureintritt)
addi x8, x2, 16

# ...

# Ende von asinh
# f10 (=fa0) enthält den Rückgabewert
fdiv.d f10, f0, f1
# Rücksprungadresse und Frame Pointer wiederherstellen
ld x1, 8(x2)
ld x8, 0(x2)
# Stack verkleinern und damit wiederherstellen
addi x2, x2, 16
# Rücksprung (ret)
jalr x0, x1, 0

</syntaxhighlight>

=== System  ===
Aspekte von RISC-V, die ein laufendes System und seine Verwaltung betreffen, werden in der privilegierten Spezifikation (genannt Band II) behandelt.<ref name=":0" /> Wie der Name „privilegiert“ besagt, ist diese besonders für Entwickler privilegierter Anwendungen (z. B. Betriebssysteme) oder Implementierer relevant, da Benutzeranwendungen selten mit diesen Aspekten interagieren.

==== Privilegienstufen ====
{{Hauptartikel|Ring (CPU)|titel1=Privilegienstufen}}
RISC-V besitzt hauptsächlich drei [[Privilegienstufen]], meist einfach Modes genannt. Nur M-Mode muss in jedem System vorhanden sein; andere Modi sind normale Architekturerweiterungen, die beispielsweise über <code>misa</code> erkannt werden können.
{| class="wikitable"
|+
!Name (Erweiterung)
!Bezeichnung
!Vorgesehen für…
|-
|align="center"|U
|User/Application
|Benutzeranwendungen oder Software in sicheren Embedded-Systemen
|-
|align="center"|S
|Supervisor
|[[Betriebssystem]]e
|-
|align="center"|M
|Machine
|[[Firmware]] oder Embedded-Software
|}
Der Debug-Modus einer debugbaren Implementierung ist streng genommen ein eigener Privilegienmodus, der Zugriff auf weitere CSRs und Speicherbereiche hat, die aus dem M-Mode nicht benutzt werden können. Außerdem wird unter der Hypervisor-Erweiterung (siehe unten) der S-Mode in mehrere Untermodi unterteilt.

Jeder Modus kontrolliert, auf welche Systemfunktionalitäten ein darüberliegender Modus Zugriff hat. M-Mode ist für die Firmware einer Implementierung gedacht, die nicht vom Betriebssystem geändert werden kann (vergleiche [[BIOS]]). M-Mode hat Zugriff auf alle Speicherbereiche, CSRs und Hardwarefunktionalitäten, auch solche, die eigentlich für höhere Modi gedacht sind. S-Mode wird von Betriebssystemen genutzt und hat Zugriff auf einen Großteil der Systemfunktionalitäten, wie die Konfiguration von virtuellem Speicher und Speicherschutzfunktionen. M-Mode kann zudem weitere Aufgaben, wie die Behandlung von Traps, an den S-Mode delegieren. Benutzerprogramme im U-Mode können per Design keinen Zugriff auf solche Funktionen haben.

==== Virtueller Speicher und Speicherschutz ====
{{Hauptartikel|Virtueller Speicher}}
RISC-V unterstützt mehrere Arten des virtuellen Speichers, die je nach Implementierung konstant oder umschaltbar sind. Ungeachtet des virtuellen Speichermodus sind Speicherseiten 4KiB groß und die unteren 12 bit einer Adresse beschreiben den Seitenoffset.

Für RV32 gibt es nur Sv32, welches eine zweistufige Seitentabelle mit je 10 Bit pro Tabellennummer verwendet. Dabei kann bereits ein Level-1-[[Page table entry|PTE]] ein Blatteintrag ohne untergeordnete Seitentabelle sein; in diesem Fall beschreibt der Eintrag eine 4-MiB-''Megapage''.

Für RV64 gibt es Sv39, Sv48 und Sv57, die entsprechend der Zahl im Namen eine bestimmte virtuelle Addressgröße haben. Bereits 39 bit (512 GiB) sind für viele heutige Anwendungen ausreichend. Alle drei virtuelle Speichermodi benutzen 9 bit pro Tabellennummer und haben 3-, 4- bzw. 5-stufige Tabellen. Die PTEs unterscheiden sich nur in Details, und auch hier gibt es die Möglichkeit, durch Blatteinträge in höherstufigen Seitentabellen ''Megapages'' (2 MiB), ''Gigapages'' (1 GiB), ''Terapages'' (512 GiB) und ''Petapages'' (256 TiB) zu erzeugen.

Speicherschutz kann auf zwei Arten erreicht werden. Zum einen mittels der 64 physischen Speicherattribute (''Physical Memory Attributes'', PMP), die in den <code>pmp</code>-CSRs festgelegt sind und eventuell nicht veränderbar sind (z. B. Nur-Lese-Attribut für ROM-Regionen). Zum anderen verfügt jede virtuelle Speicherregion über (im S-Mode) konfigurierbaren Speicherschutz, der während der Adressübersetzung geprüft wird. RISC-V definiert die Zugriffsarten Lesen, Schreiben und Ausführen, wobei das Ausführen eines Speicherworts nicht als Lesezugriff gilt. Code kann also als nicht lesbar konfiguriert werden, was einen Zugriff mit Speicherzugriffsbefehlen verhindert. Außerdem kann eine Speicherregion als vom U-Mode nicht zugreifbar definiert werden.

==== Umgebungsaufrufe und SBI ====
Um Funktionalität des umgebenden Systems abrufen zu können, besitzt RISC-V ein verallgemeinertes [[Systemaufruf]]-Verfahren, das ''Environment Calls'', d. h. Umgebungsaufrufe, genannt wird. Der dafür zuständige Befehl <code>ecall</code> (Teil der I-Basisarchitektur) kann in jedem Privilegienmodus genutzt werden, um ein Trap (d. h. Softwareinterrupt) in den nächsthöheren Modus auszulösen. Dieser kann die Anfrage dann behandeln und mittels <code>mret</code> oder <code>sret</code> die Kontrolle an den anfragenden Modus zurückgeben. Welche Funktionen verfügbar sind und wie Argumente übergeben werden, definiert die ABI (für U-Mode nach S-Mode, d. h. Systemaufruf) oder SBI (''Supervisor Binary Interface'' für S-Mode nach M-Mode, d. h. Firmwareinterface). Üblicherweise ähnelt die Aufrufkonvention der normalen Prozeduraufrufkonvention, z. B. werden Argumente in den Argumentregistern a0-a7 übergeben.

Die SBI ist standardisiert<ref>{{Internetquelle |autor=Palmer Dabbelt, Atish Patra |url=https://github.com/riscv-non-isa/riscv-sbi-doc |titel=RISC-V Supervisor Binary Interface Specification |hrsg=RISC-V Platform Specification Task Group |datum=2023-12-05 |format=PDF; 323 KB |sprache=en |abruf=2023-12-13}}</ref> und definiert eine Reihe an Funktionen und Erweiterungen, deren Vorhandensein von S-Mode-Software abgefragt werden und dann verwendet werden kann. Dabei werden Register a7 für die ID der Erweiterung und Register a6 für die Funktion innerhalb der Erweiterung genutzt. Beispielsweise kann mit Erweiterung 16 (verpflichtende Basiserweiterung) und Funktion 0 die implementierte SBI-Spezifikationsnummer abgerufen werden, oder mit Erweiterung 4442434E16 und Funktion 2 ein Textzeichen auf der Debugging-Konsole ausgegeben werden.<ref>{{Internetquelle |url=https://github.com/riscv-non-isa/riscv-sbi-doc/blob/master/src/ext-debug-console.adoc |titel=Debug Console Extension |datum=2023-12-13 |sprache=en |abruf=2023-12-13}}</ref>

==== Virtualisierung ====
{{Hauptartikel|Hypervisor|Virtualisierung (Informatik)|titel2=Virtualisierung}}
Zur Unterstützung der Virtualisierung bietet RISC-V die Hypervisor-Erweiterung, die S-Mode in einen HS-Mode (''hypervisor extended supervisor'') und VS-Mode (''virtual supervisor'') aufteilt. HS-Mode erhält Zugriff auf eine Reihe an speziellen CSRs und kann zudem die Supervisor-CSRs des VS-Mode separat konfigurieren. Ein Umgebungsaufruf aus dem VS-Mode wird nun vom HS-Mode (statt M-Mode) behandelt, sodass der Hypervisor z. B. eine völlig andere Firmware und virtuelle Geräte emulieren kann, als eigentlich hardwareseitig vorhanden ist. Auch können Traps an den VS-Mode delegiert werden, beispielsweise um direkten Zugriff auf physische Hardware zu erlauben. VS-Mode besitzt seinen eigenen virtuellen Speicher, der in zwei Stufen übersetzt wird: zunächst von virtuellen Gastadressen in physische Gastadressen (entsprechend normalen virtuellen Adressen), und dann von physischen Gastadressen in physische Adressen. Mittels spezieller Hypervisor-Befehle (<code>hlv</code>, <code>hlvx</code> etc.) kann der Hypervisor (oder ein Benutzerprogramm im HU-Mode) wie VS-Mode mit virtuellen Gastadressen Speicherzugriffe ausführen.

== Auszeichnungen ==
* 2017: The Linley Group's Analyst's Choice Award for Best Technology (für den Befehlssatz)<ref>{{Literatur |Titel=The Linley Group Announces Winners of Annual Analysts' Choice Awards |Datum=2017-01-12 |Online=http://linleygroup.com/press_detail.php?The-Linley-Group-Announces-Winners-of-Annual-Analysts-Choice-Awards-85 |Abruf=2018-01-21}}</ref>

== Implementierungen ==
RISC-V ist ein offener Standard, welcher eine Befehlssatzarchitektur spezifiziert, aber weder eine Mikroarchitektur noch ein Lizenzmodell vorgibt. Aus diesem Grund wurden sowohl RISC-V Kerne mit kommerzieller Lizenz als auch mit Open-Source-Lizenz entwickelt. Die RISC-V-Stiftung pflegt eine Liste aller RISC-V-CPU- und -SoC-Implementierungen.<ref>{{Internetquelle |url=https://github.com/riscv/riscv-cores-list |titel=riscv/riscv-cores-list |hrsg=RISC-V |datum=2021-05-16 |abruf=2021-05-17}}</ref>

=== Proprietäre RISC-V-Kerne ===
[[Datei:Starfive VisionFive2 Single Board Computer.jpg|mini|hochkant=1.1|VisionFive 2-Einplatinencomputer von StarFive mit vier U74-Kernen von SiFive]]
* Das [[Fraunhofer-Institut für Photonische Mikrosysteme|Fraunhofer IPMS]] war die erste Organisation, die einen RISC-V Kern entwickelt hat, der den Anforderungen nach funktionaler Sicherheit gerecht wird. Der IP Core EMSA5 ist ein 32-Bit-Prozessor mit fünfstufiger Pipeline und ist als General Purpose Variante (EMSA5-GP) und als Safety Variante (EMSA5-FS) mit einer ASIL-D ready Zertifizierung nach der [[ISO 26262|ISO 26262:2018]] für funktionale Sicherheit erhältlich.<ref>{{Internetquelle |autor=Michael Eckstein |url=https://www.elektronikpraxis.vogel.de/bis-asil-d-erster-nach-iso-26262-zertifizierbarer-risc-v-core-a-1049317/ |titel=Bis ASIL-D: Erster nach ISO 26262 zertifizierbarer RISC-V-Core |sprache=de |abruf=2022-04-13}}</ref>
* Andes Technology Corporation bietet mehrere Familien von RISC-V-Kernen an, mit unterschiedlichen optionalen Erweiterungen, darunter einige mit Multiprozessorfähigkeiten:<ref>{{Internetquelle |autor=Andes Technology Corporation |url=https://www.globenewswire.com/news-release/2020/11/30/2136635/0/en/Andes-Announces-New-RISC-V-Processors-Superscalar-45-Series-with-Multi-core-Support-and-27-Series-with-Level-2-Cache-Controller.html |titel=Andes Announces New RISC-V Processors: Superscalar 45-Series with Multi-core Support and 27-Series with Level-2 Cache Controller |datum=2020-11-30 |abruf=2021-05-17 |sprache=en}}</ref>
** Die “N(X)”-Familie besteht sowohl aus 32-bit (N) als auch 64-bit (NX) Kernen. Deren Pipeline-Länge variiert dabei von zwei Stufen im N22 bis zu acht Stufen im N45. Der NX27V unterstützt die RISC-V “V”-Erweiterung.<ref>{{Internetquelle |autor=Nitin Dahad |url=https://www.eetimes.com/andes-core-has-risc-v-vector-instruction-extension/# |titel=Andes’ Core has RISC-V Vector Instruction Extension |werk=EE Times |datum=2019-09-12 |abruf=2021-05-17 |sprache=en}}</ref>
** Die “D(X)”-Familie besteht aus Kernen mit “P”-Erweiterung für SIMD-Instruktionen und verfügt sowohl über 32-bit (D) als auch 64-bit (DX) Kerne.
** Die “A(X)”-Familie besteht aus Linux-fähigen Prozessorkernen mit Pipelines von fünf bis acht Stufen. Die Kerne integrieren [[Gleitkommazahl|Gleitkommaeinheiten]] und MMUs.
* Codasip war das erste Unternehmen, welches einen RISC-V-konformen, kommerziellen Prozessorkern im Januar 2016 auf den Markt brachte (Codix)<ref>{{Internetquelle |url=https://www.design-reuse.com/news/38964/codasip-risc-v-compliant-codix-processor-ip.html |titel=Codasip Joins RISC-V Foundation and Announces Availability of RISC-V Compliant Codix Processor IP |abruf=2021-05-17 |sprache=en}}</ref> und bietet seitdem eine Reihe von Prozessorkernen für eingebettete Systeme sowie betriebssystembasierte Anwendungen an. Codasips Prozessorkerne sind mittels der Entwicklungsumgebung “Codasip Studio” in CodAL<ref>{{Internetquelle |url=https://codasip.com/2021/02/26/what-is-codal/ |titel=What is CodAL? |datum=2021-02-26 |abruf=2021-05-21 |sprache=en-US}}</ref> entwickelt, einer Architektur-Beschreibungssprache (Architecture Description Language):
** Die “L”-Familie besteht aus energiesparenden 32-bit-Kernen für eingebettete Systeme mit optionaler Gleitkommaeinheit und entweder drei- oder fünfstufiger Pipeline.
** Die “H”-Familie besteht aus leistungsfähigen 64-bit-Kernen für eingebettete Systeme mit optionaler Gleitkommaeinheit, ebenfalls mit drei- oder fünfstufiger Pipeline.
** Die “A”-Familie besteht aus Linux-fähigen 64-bit-Kernen mit optionaler “P”-Erweiterung. Die Prozessorkerne haben eine siebenstufige Pipeline, eine Gleitkommaeinheit und eine MMU. Zusätzlich unterstützen die “MP”-Versionen mit L1- und L2-Caches bis zu vier Kerne pro Cluster.<ref>{{Internetquelle |url=https://www.newelectronics.co.uk/electronics-news/codasip-announces-risc-v-processor-cores-providing-multi-core-and-simd-capabilities/232807/ |titel=Codasip announces RISC-V processor cores providing multi-core and SIMD capabilities |abruf=2021-05-17 |archiv-url=https://web.archive.org/web/20201223193035/https://www.newelectronics.co.uk/electronics-news/codasip-announces-risc-v-processor-cores-providing-multi-core-and-simd-capabilities/232807/ |archiv-datum=2020-12-23 |offline=ja |archiv-bot=2024-04-21 12:42:18 InternetArchiveBot }}</ref>
** Die “uRISC-V”-Kerne sind einfache Kerne, verfügbar als Teil von Codasip Studio und gedacht für Lehr- und Selbstlernzwecke.<ref>{{Internetquelle |url=https://www.design-reuse.com/news/49787/codasip-studio-codespace-9-0.html |titel=Codasip Releases a Major Upgrade of Its Studio Processor Design Toolset with a Tutorial RISC-V core |abruf=2021-05-17 |sprache=en}}</ref>
* [[Datei:SiFive HiFive1 (31607369743).png|mini|hochkant=1.1|HiFive1-Mikrocontroller von [[SiFive]] (links), [[Arduino (Plattform)|Arduino]] Uno (rechts, blau)]]SiFive war das erste Unternehmen, welches mit dem FE310 einen RISC-V basierten-SoC auf den Markt brachte.<ref>{{Internetquelle |url=https://community.cadence.com/cadence_blogs_8/b/breakfast-bytes/posts/risc-v-sifive |titel=RISC-V Available in Silicon |abruf=2021-05-17 |sprache=en}}</ref> Aktuell bietet SiFive drei Produktfamilien an:
** Die “E”-Kerne sind 32-bit-Kerne für eingebettete Systeme mit zwei- bis achtstufiger Pipeline. Das fortschrittlichste Produkt dieser Familie ist der vierkernige E76-MC.
** Die “S”-Kerne sind 64-bit-Kerne für eingebettete Systeme mit zwei- bis achtstufiger Pipeline. Das fortschrittlichste Produkt aus dieser Familie ist der vierkernige S76-MC.
** Die “U”-Kerne sind Linux-fähige 64-bit-Kerne mit fünf bis zwölf Pipelinestufen. Der U54 und der U74 sind auch in multiprozessorfähigen Versionen verfügbar. Der performanteste Kern dieser Familie ist der dreifach superskalare U84.<ref>{{Internetquelle |url=https://www.hackster.io/news/sifive-announces-u8-series-2-6ghz-high-performance-out-of-order-risc-v-core-ip-96c6209ed7c4 |titel=SiFive Announces U8-Series 2.6GHz High-Performance Out-of-Order RISC-V Core IP |abruf=2021-05-17 |sprache=en}}</ref>
** Der “Intelligence X280” ist ein von der “U”-Familie abgeleiteter, ebenfalls Linux-fähiger Prozessorkern, welcher zusätzlich die “V”-Erweiterung für Vektorberechnungen unterstützt.<ref>{{Internetquelle |autor=Andreas Schilling |url=https://www.hardwareluxx.de/index.php/news/hardware/prozessoren/56018-neuer-intelligence-x280-von-sifive-verbindet-risc-v-mit-vektorbeschleunigung.html |titel=Neuer Intelligence X280 von SiFive verbindet RISC-V mit Vektorbeschleunigung |abruf=2021-05-17 |sprache=de}}</ref>

=== Quelloffene RISC-V-Kerne ===

* Die [[University of California, Berkeley]] hat eine Reihe RISC-V-Kerne unter Verwendung von Chisel, einer Hardware-Beschreibungssprache, entwickelt. Dies sind unter anderem:
** Der 64-bit-Kern “Rocket”,<ref>{{Internetquelle |url=https://github.com/chipsalliance/rocket-chip |titel=chipsalliance/rocket-chip |hrsg=CHIPS Alliance |datum=2021-05-15 |abruf=2021-05-17}}</ref> geeignet für kompakte und energiesparende Anwendungen mit mittleren Performanzanforderungen, z. B. elektronischen Kleingeräten für den persönlichen Bedarf.
** Der 64-bit-Kern “Berkeley Out of Order Machine” oder “BOOM”, ein synthetisier- und parametrisierbarer, quelloffener RV64GC-RISC-V-Kern, welcher für Anwendungen im Bereich Personal Computing, aber auch für Rechenzentren und Serverfarmen geeignet ist.
** Fünf 32-bit “Sodor” CPU-Designs<ref>{{Internetquelle |url=https://github.com/ucb-bar/riscv-sodor |titel=ucb-bar/riscv-sodor |hrsg=UC Berkeley Architecture Research |datum=2021-05-09 |abruf=2021-05-17}}</ref> wurden für Bildungszwecke entworfen.
* PULPino (“Riscy” und “Zero-Riscy”) der [[ETH Zürich]] / [[Universität Bologna]].<ref>{{Internetquelle |url=https://www.pulp-platform.org/ |titel=PULP platform |abruf=2021-05-17}}</ref> Die Prozessorkerne des PULPino-Projekts implementieren einen simplen “RV32IMC”-RISC-V-Befehlssatz für Mikrocontroller (“Zero-Riscy”) oder einen leistungsfähigeren “RV32IMFC”-RISC-V-Befehlssatz mit individuellen DSP-Erweiterungen für eingebettete Signalverarbeitung.
* CVA6 der OpenHWGroup.<ref>{{Internetquelle |url=https://docs.openhwgroup.org/projects/cva6-user-manual/index.html |titel=CVA6: An application class RISC-V CPU core — CVA6 documentation |abruf=2023-12-12}}</ref> Die Prozessorkerne der CVA6-Familie sind quelloffene, in [[SystemVerilog]] geschriebene sogenannte Application-Class-Prozessoren. Dies bedeutet, dass sie einen Großteil der privilegierten Spezifikation implementieren und in der Lage sind, übliche Embedded-Betriebssysteme wie Embedded [[Linux]] oder [[FreeRTOS]] auszuführen. Sie besitzen eine sechsstufige In-Order-Pipeline und unterstützen je nach Konfiguration RV32GC bzw. RV64GC und diverse andere Erweiterungen. Das CVA6-Projekt entstammt dem ARIANE-Prozessor der ETH Zürich / Universität Bologna, die nach den einfacheren PULPino-Prozessoren einen praktisch einsetzbaren Prozessor entwickeln wollten.<ref>{{Literatur |Autor=Luca Benini |Titel=Ariane: An open-source 64-bit RISC-V Application-Class Processor and latest Improvements |Datum=2018-05-09 |Online=https://riscv.org/wp-content/uploads/2018/05/14.15-14.40-FlorianZaruba_riscv_workshop-1.pdf |Format=PDF |KBytes=2568}}</ref>
* [[Western Digital]] hat seine “SweRV” genannten RISC-V-Kerne durch die “CHIPS Alliance” als quelloffen verfügbar gemacht. Des Weiteren kündigte Western Digital eine Kooperation mit Codasip an, um den kommerziellen Support der Prozessoren zu ermöglichen.<ref>{{Internetquelle |url=https://www.eenewseurope.com/news/codasip-partners-western-digital-open-source-processors |titel=Codasip partners with Western Digital on open‑source processors |datum=2019-12-10 |abruf=2021-05-17 |sprache=en}}</ref> Diese Kerne sind für anspruchsvolle eingebettete Anwendungen konzipiert und unterstützen den “RV32IMC”-RISC-V-Befehlssatz. Im Detail sind es:
** Der “SweRV Core EH1”, welcher zweifach superskalar ist und eine neunstufige Pipeline hat.
** Der “SweRV Core EH2”,<ref>{{Internetquelle |autor=Anton Shilov |url=https://www.anandtech.com/show/15231/western-digital-rollsout-two-new-swerv-riscv-cores |titel=Western Digital Rolls-Out Two New SweRV RISC-V Cores For Microcontrollers |abruf=2021-05-17}}</ref> welcher ebenfalls zweifach superskalar ist und eine neunstufige Pipeline hat, aber auch Hardwareunterstützung für zwei parallele Threads bietet.
** Der “SweRV Core EL2”, als einfach skalarer Kern mit vierstufiger Pipeline.
== Software ==
Folgende [[Betriebssystem]]e wurden, unter anderem, auf die RISC-V Prozessorarchitektur portiert:
* [[Linux]]
* [[OpenBSD]]
* [[NetBSD]]
* [[FreeBSD]]
* [[Haiku (Betriebssystem)|Haiku]]
* [[Plan 9 (Betriebssystem)|Plan 9]]
* [[RISC OS]]
* [[OpenSolaris]]

Außerdem können Programme mithilfe von verschiedenen Kompilern wie z. B. der [[GNU Compiler Collection]] und [[LLVM]] zu RISC-V-Maschinencode kompiliert werden.

== RISC-V in nationalen- und supranationalen Förderbestrebungen ==

RISC-V ist als variable [[Befehlssatzarchitektur]] interessant für nationale- sowie supranationale Förderung als Reaktion auf die [[Chipkrise]], beispielsweise um effizientere Mikroprozessoren zu entwickeln. Im [[Europäisches Chip-Gesetz|Europäischen Chip-Gesetz]] wird RISC-V als eine vielversprechende Architektur angesehen, um Prozessoren mit niedrigem Stromverbrauch zu entwickeln und den Versorgungsengpässen bei [[Halbleiter]]n entgegenzuwirken, indem die Produktion in [[Europäische Union|Europa]] gesteigert wird.<ref>{{Internetquelle |url=https://eur-lex.europa.eu/legal-content/DE/TXT/PDF/?uri=CELEX:32023R1781 |titel=Verordnung (EU) 2023/1781 des Europäischen Parlaments und des Rates vom 13. September 2023 zur Schaffung eines Rahmens für Maßnahmen zur Stärkung des europäischen Halbleiter-Ökosystems und zur Änderung der Verordnung (EU) 2021/694 (Chip-Gesetz) (Text von Bedeutung für den EWR) |werk=EUR-Lex |datum=2023-09-13 |abruf=2024-01-09}}</ref><ref>{{Internetquelle |url=https://www.acatech.de/publikation/risc-v/ |titel=RISC-V: Potenziale eines offenen Standards für Chipentwicklung |werk=acatech IMPULS |datum=2023-11-08 |abruf=2024-01-09}}</ref>

In den [[Vereinigte Staaten|USA]] gibt es ebenfalls Bestrebungen, die Entwicklung energieeffizienter Prozessoren mit Hilfe des [[CHIPS and Science Act]] zu forcieren.<ref>{{Internetquelle |url=https://www.congress.gov/117/plaws/publ167/PLAW-117publ167.pdf |titel=CHIPS Act of 2022 |werk=PUBLIC LAW 117–167 |datum=2022-08-09 |abruf=2024-01-09}}</ref>

== Hersteller entsprechender Chips ==
* [[Datei:RISC-V ESP32-C6-WROOM-1.devboard.jpg|mini|177x177px|[[ESP32]]-C6 von Espressif]][[Alibaba Group|Alibaba]]
* [[Allwinner]]
* [[Espressif]]<ref>{{Internetquelle |url=https://www.all-electronics.de/elektronik-entwicklung/espressif-kuendigt-wi-fi-6-und-bluetooth-5-soc-mit-risc-v-kern-an-240.html |titel=Espressif kündigt Wi-Fi-6- und Bluetooth-5-SoC mit RISC-V-Kern an |werk=all-electronics.de |datum=2021-04-23 |abruf=2021-11-18}}</ref>
* [[GigaDevice]]
* [[Intel]]
* [[Maxim Integrated]] subsidiary of [[Analog Devices]]
* [[Micro Magic]]
* Microsemi Corporation subsidiary of [[Microchip Technology Inc.]]
* [[SiFive]]
* [[Western Digital]]
* Huami
* [[HiSilicon]]
* [[Google LLC|Google]]<ref>{{Internetquelle |autor=Sebastian Grüner |url=https://www.golem.de/news/titan-m2-googles-security-chip-nutzt-risc-v-2110-160659.html |titel=Googles Security-Chip nutzt RISC-V |werk=[[golem.de]] |datum=2021-10-28 |abruf=2021-11-09}}</ref>
* [[IHP GmbH - Innovations for High Performance Microelectronics/Leibniz-Institut für innovative Mikroelektronik|Leibniz IHP]]<ref>{{Internetquelle |autor=Christof Windeck |url=https://www.heise.de/news/Open-Source-Hardware-Sicherheitschip-mit-offenen-Tools-in-Brandenburg-gefertigt-9340167.html |titel=Deutsches Projekt entwickelt quelloffenen Sicherheits-Chip in zwei Jahren |werk=heise online |datum=2023-10-20 |sprache=de |abruf=2023-10-22}}</ref>
* JH7110 von [[StarFive]]<ref>{{Internetquelle |url=https://www.kickstarter.com/projects/starfive/visionfive-2 |titel=VisionFive 2 - open source quad-core RISC-V dev board |werk=Kickstarter |datum=2023-05-23 |sprache=en |abruf=2023-12-25}}</ref>
* [[Raspberry Pi]] Foundation (Raspberry Pi Pico 2)

== Siehe auch ==
* [[OpenRISC]]

== Weblinks ==
{{Commonscat}}
* [https://riscv.org/ Offizielle Website der RISC-V Foundation]

== Einzelnachweise ==
<references />

{{Navigationsleiste programmierbare Logik}}

[[Kategorie:Prozessorarchitektur nach Befehlssatz]]
[[Kategorie:Prozessorarchitektur]]

MikroSim

2015-01-01T00:17:43Z

SimDoc: Software ist proprietär, aber Freeware, wenn nicht lizensiert.

{{Infobox Software
| Logo = [[Datei:MikroSim2010_Icon.jpg|miniatur|80px|zentriert|Logo von MikroSim 2010]]
| Screenshot =[[Datei:Screenshot_MikroSim2010.png|miniatur|250px|zentriert|Bildschirmfoto der Windows-Applikation MikroSim 2010]]
| AktuelleVersion = 3.0.13
| AktuelleVersionFreigabeDatum = 20.6.2012
| Entwickler = Martin Perner
| Hersteller = 0/1-SimWare
| Betriebssystem = [[Microsoft Windows|Windows]]
| Programmiersprache = Visual Basic
| Lizenz = [[proprietär]]e [[Freeware]]/[[Shareware]]
| Deutsch = ja
| Website = [http://www.mikrocodesimulator.de www.mikrocodesimulator.de]
}}

Das Programm '''MikroSim''' ist eine [[Lernsoftware]] für das [[Betriebssystem]] [[Microsoft Windows]] zur hardware-unspezifischen Erläuterung der allgemeinen Funktionsweise und Steuerabläufe einer virtuellen Rechenmaschine. Es lassen sich in allgemein verständlicher Weise miniaturisierte [[Rechenwerk]]e didaktisch auf [[Registertransferebene]] erläutern, die in [[Mikrocontroller]]n, [[Prozessor (Hardware)|Prozessoren]], und [[Computer]]n ablaufen.

== Allgemeines ==
Anfänglich wurde MikroSim als Prozessor-Simulationssoftware konzipiert. Da MikroSim allerdings die Programmierbarkeit ([[Mikroprogrammierung]]) eines [[Mikroprogrammsteuerwerk]]s mittels [[Mikrobefehl]]en in den Vordergrund stellt, betont die Anwendung als [[Mikrocodesimulator]] den Aspekt der Mikrocodesimulation. In der gegenwärtigen Entwicklung erlangt der [[Simulator]] den Status einer virtuellen Applikation. Dabei werden allgemeine Prinzipien der System- und [[Rechnerarchitektur]] aufgegriffen, die sich mit dem Beginn des [[Informationszeitalter]]s etabliert haben und noch heute Bestand haben, ohne sich auf spezielle Hardwareaspekte zu beschränken. Auf diese Weise erlangt das Simulationswerkzeug einen zeitlosen, freien didaktischen Nutzen, ohne sich auf spezielle vergangene und zukünftige Entwicklungen festzulegen. Die detaillierte Dokumentation und die zweisprachige Benutzerführung der [[E-Learning]]-Anwendung in Deutsch und Englisch, sowie die Auslegung der Software für die weithin verbreiteten Windows-Betriebssysteme, ist der Grund für den nachhaltigen Bestand der Software im Lehrbetrieb auf dem Gebiet der [[technische Informatik|technischen Informatik]] in Ausbildung und Lehre seit 1992.

== Entwicklungsgeschichte ==
Die Software basiert auf einer freien, unter [[Turbo-Pascal]] für das Betriebssystem [[MS-DOS]] geschriebenen Programmversion, die bis 1992 an der [[Philipps-Universität Marburg]] in der Vorlesung zur technischen Informatik für die Erläuterung von Mikrocodesteuerprozessen herangezogen wurde. Das bis dahin etablierte didaktische Vorlesungskonzept wurde im Sommer 1992 von Martin Perner während seines Physik-[[Diplom]]studiums (1990–1995) aufgegriffen und in freier Arbeit auf das Betriebssystem [[Microsoft Windows 3.x|Windows 3.1]] unter [[Visual Basic]] 1.0 portiert. Dabei entstand der Simulator in einer für damalige Verhältnisse völlig neuartigen Konzeption mit weitreichender Funktionalitätsverbesserung. Die Weiterentwicklung der Lehrsoftware unter Windows wurde bis 1995 von dem Fachbereich Mathematik/Informatik der Universität Marburg durch Heinz-Peter Gumm gefördert. Der Simulator wurde im November 1994 mit dem ''Europäischen Hochschul-Software-Preis 1994'' in der Kategorie [[Informatik]] in [[Heidelberg]] ausgezeichnet und im März 1995 auf der Computermesse [[CeBit]] in Hannover am Stand der hessischen Hochschulen der Öffentlichkeit vorgestellt.

Im Zeitraum Ende 1995 bis Anfang 2000 wurde der Simulator mit wenigen Verbesserungen unter der Revision MikroSim 1.2 veröffentlicht. In diesem Zeitraum wurde MikroSim im Rahmen des ''Europäischen Jahres des lebensbegleitenden Lernens 1996'' mit 1000 ECU prämiert, sowie beim Wettbewerb ''Multimedia Transfer'97'' im Rahmen der Messe ''LearnTec’97'' vorgestellt.<ref>[http://www.mikrocodesimulator.de/index.php#PreiseAuszeichnungen Preise und Auszeichnungen] auf der MikroSim-Website (Abgerufen am 5. November 2010.)</ref> In seiner vorletzten Neuauflage wurde der Simulator unter dem Namen „Mikrocodesimulator MikroSim2000“ mittels der Programmiersprache MS-Visual Basic 4.0 für [[Microsoft Windows 95|Windows 95]] angepasst.

Im Zeitraum Anfang 2008 bis 2009 erfuhr der Simulator weitreichende konzeptionelle Erweiterungen, ohne die Möglichkeiten der Mikrocodesimulation im Kern zu verändern. Dabei wird die Rechenleistung heutiger Windows-Applikationen und der verwendeten Hardware ausgenutzt, um Simulationen bis hin zur virtuellen Applikation zu ermöglichen.
MikroSim ist als 32-Bit-Version kompiliert und für [[Microsoft Windows XP|Windows XP]] optimiert worden. Das Programm ist auf allen 32- und 64-Bit-Betriebssystem der Versionen [[Microsoft Windows Vista| Windows Vista]] und [[Microsoft Windows 7|Windows 7]] ohne spezielle XP-Kompatibilitätsmodi ausführbar. Seit Januar 2010 wird der Simulator unter „Mikrocodesimulator MikroSim 2010“ von 0/1-SimWare vertrieben.

== Funktionsweise und -umfang ==
Das Programm ermöglicht den schrittweisen Aufbau einer virtuellen Applikation, die in ihrer Funktionalität unveränderbar vorgegeben ist. Im Erkundungsmodus kann die Funktionsweise und Steuerungsmöglichkeit neu hinzugefügter Komponenten innerhalb eines Mikrocode-Befehlszyklus in Erfahrung gebracht werden. Die Breite der von MikroSim unterstützten Mikrobefehle umfasst 49 Bit. Ein Mikrobefehl wird in drei Teilphasen eines 3-Phasentakts abgearbeitet. Die Teilphasen werden als Hol-, Rechen- und Bringphase bezeichnet und bewirken das Holen eines 32 Bit breiten Registerwerts, das Ausführen einer 32-Bit-Berechnung, und das abschließende Speichern des Rechenergebnisses in einem CPU-internen [[Register (Computer)|Register]].

Im Simulationsmodus können hintereinander ausgeführte Mikrobefehle die zentrale Recheneinheit des Simulators steuern, wobei jeder Mikrobefehl auf die Adresse des nächsten Mikrobefehls verweist. Der Mikrobefehlssatz, gemeinhin als „Mikrocode“ der Recheneinheit bezeichnet, umfasst in der gegenwärtigen Implementierung von MikroSim 1024 49-Bit-lange Mikrobefehle. Strukturierungsmöglichkeiten im adressierbaren Ablaufplan im Mikrocode und die Entwicklung eines zyklisch arbeitenden, mikrocodeprogrammierten [[Interpreter]]s für Operationscodes (kurz [[Opcode]]s) ermöglichen die Implementierung von einzelnen mikrocodeprogrammierten Mikrobefehlssequenzen. Diese können als mikroprogrammierte [[Maschinenbefehl]]e aufgefasst werden. Der Mikrocode kann als [[Firmware]] für MikroSim als Mikrocode-[[Read-Only Memory|ROM]]-Datei (ROM, engl. {{lang|en|Read-Only Memory}}) abgelegt, modifiziert und erneut geladen werden.

Innerhalb eines Mikrobefehlzyklus kann sowohl die CPU als auch ein Ein-Ausgabe-Kontroller auf einen externen 16 kB umfassenden [[Random-Access Memory|RAM]]-[[Datenspeicher]] (RAM, engl. {{lang|en|Random-Access Memory}}) zurückgreifen. Über den Ein-Ausgabe-Kontroller erfolgt die Kommunikation mit angeschlossenen Ein- und Ausgabekomponenten mit [[Direct Memory Access|DMA]]-, [[I2C|I2C]]- und [[Interrupt Request|IRQ]]-Funktionalität. Unterstützt werden ein Ausgabe-Port, eine Anzeige, ein Zeitgeber, ein Ereignis-Trigger, ein Digital-Analog-Wandler, eine Tastatur und Daten-Ein-Ausgabe-Kanäle.

Der Mikrocodesimulator verwendet acht frei verwendbare 32-Bit-Register, deren Inhalt für vorzeichenbehaftete und vorzeichenlose Ganzzahlberechnungen, sowie für 32-Bit-Gleitkommaarithmetik eingesetzt werden. Mit einem übersichtlichen Systemzahleditor können die Registerinhalte betrachtet und modifiziert werden.

Die zentrale Recheneinheit des Simulators, die 32-Bit-[[Arithmetisch-logische Einheit|ALU]], unterstützt 128 verschiedene, grundlegende Rechenoperationen für Ganzzahlen und Interrupt-Steuerung bis hin zur [[Gleitkommaarithmetik]], die als erstes in vergleichbarer Weise bereits von [[Konrad Zuse]] eingeführt wurde. Zur Verdeutlichung dieser Arithmetik stehen elementare Rechenoperationen für die schrittweise auflösbare Gleitkomma-Registeroperationen in Mantisse und Exponent von den Grundberechnungen Addition/Subtraktion und Multiplikation/Division zur Verfügung. Weiterführend werden darauf aufbauend mächtigere 32-Bit-Rechenbefehle der Gleitkommaarithmetik in Mantisse und Exponent für die [[Grundrechenart]]en und elementarer analytischer Funktionen bereitgestellt, wie sie in mathematischen [[Coprozessor]]en realisiert sind. Dabei wird idealisiert angenommen, dass jede der 128 unterstützten ALU-Rechenoperationen für die Ausführung nur einen virtuellen Rechentakt benötigt.

Die Mikrobefehle können auf verschiedenen Simulationsniveaus ausgeführt werden:
* In dem niedrigsten Simulationsniveau unterstützt der Simulator die phasenweise Abarbeitung eines Mikrobefehls, der in eine sogenannte Hol-, Rechen- und Bring-Phase unterteilt ist. Die Abarbeitung der Teilphasen ist mit einer einstellbaren Verzögerung zur besseren Nachverfolgung möglich.
* Darauf aufbauend ist die komplette Abarbeitung eines Mikrobefehls in einem Dreiphasen-Takt ohne Verzögerung möglich. Ebenso die Abarbeitung mehrerer zu einem Maschinenbefehl zusammenfassbarer Mikrobefehle mittels eines in Mikrocode programmierten Maschinencodeinterpreters. Der Interpreter hat die Aufgabe, Maschinensprachebefehle, als Operationscodes in einem Byte-Wert codiert, aus dem RAM zu holen und an die entsprechende Mikrocodeunterprogrammadresse zur mikroprogrammierten Ausführung zu verzweigen.
* Darüber hinaus ist die Abarbeitung mehrerer Maschinenbefehle bis zu einem frei definierbaren Haltepunkt möglich. Dabei kann die Zeit bis zum Erreichen des Halte-Punkts für Simulationsoptimierungen gestoppt werden.
* Im höchsten Simulationsniveau kann der Mikrocodesimulator im Freilauf-Modus ohne jegliche Unterbrechung Maschinensprachesequenzen abarbeiten und somit die Interaktion der Applikation mit Ein- und Ausgabeschnittstellen in den Vordergrund rücken.

Mit verschiedenen Zusatzoptionen können visuelle CPU-Aktivitäten zu Gunsten der Steigerung der Abarbeitungsgeschwindigkeit unterdrückt werden, so dass die Maschinenprogrammierung der virtuellen Applikation in den Vordergrund tritt.
Mit dem Performance-Index-Monitor bietet der Simulator die Möglichkeit, die Abarbeitungsgeschwindigkeit und Ausführungsdauer entworfener Mikrobefehl-Sequenzen zu bestimmen und diese in Bezug zur Rechenleistung, gemessen in Gleitkommaoperationen pro Sekunde (FLOPS, engl. {{lang|en|[[Floating Point Operations Per Second]]}}) und [[Instruktionen pro Sekunde|Maschinen-/Mikrobefehle pro Sekunde]] (MIPs, engl. {{lang|en|Million Instructions per Second}}), der verwendeten Simulationshardware zu setzen.

Mit dem Zusatzprogramm MikroBAT, dem sogenannten „Basic Assembler Tool“ für MikroSim, können einfache Programme in [[Assembler (Informatik)|Assembler]] erstellt werden. Dabei wird der Befehlsumfang unterstützter [[Mnemonic]]s durch den Satz eigener mikrocodeprogrammierter Maschinenbefehle (Opcode) bestimmt. Das Zusatzprogramm ist in der Lage, das Assembler-Programm in Maschinencodes zu übersetzen und in den externen Datenspeicher für anschließende Simulationen zu übertragen.
Zusammen mit MikroBAT behandelt der Mikrocodesimulator in didaktisch aufbauender Weise Lehraspekte der technischen Informatik vom schaltergesteuerten Rechenautomaten bis zur Assembler programmierbaren Applikation.

== Literatur ==
* H.P.Gumm, M.Sommer: ''Einführung in die Informatik'', 8. Auflage. Oldenbourg, München 2009, ISBN 978-3-486-58724-1, (Zu MikroSim insbesondere Kap. 5.6, S.470-485.)

== Weblinks ==
* [http://www.mikrocodesimulator.de Mikrocodesimulator MikroSim] – Offizielle Website

== Einzelnachweise ==
<references />

[[Kategorie:Virtualisierung]]
[[Kategorie:Lernsoftware]]
[[Kategorie:Rechnerarchitektur]]
[[Kategorie:Assembler]]
[[Kategorie:Technische Informatik]]

Boji

2014-11-01T10:15:58Z

SimDoc: Link meaningless and removed

[[Datei:Pyrite-271406.jpg|miniatur|''Boji'' aus [[Dongchuan]], Kunming, Yunnan, China (Größe: 6,2 cm x 6,2 cm x 5,0 cm)]]
[[Datei:Pyrite-278501.jpg|miniatur|Weiterer ''Boji'' aus dem gleichen Fundort, aber von anderer Form (Größe: 7,9 cm x 7,5 cm x 6,4 cm)]]
'''Boji''' (auch ''Bojistein'') ist ein [[Handelsname]] und ein geschütztes [[Marke (Recht)|Warenzeichen]] der Firma Boji Inc. für eine spezielle [[Varietät (Mineralogie)|Varietät]] von [[Pyrit]], genauer ein [[Mineral-Aggregat]] oder besser eine [[Konkretion]] aus Pyrit und [[Limonit]] mit knollig-kugeligem oder auch linsenförmigem Aussehen. Um den Handelsnamen zu umgehen, sind gelegentlich auch Bezeichnungen wie '''Kiesball''' oder '''Pop-Rock''' im Umlauf.

== Bildung und Fundorte ==
Bojisteine entstehen sekundär durch die Freisetzung von [[Schwefel]] beim Zerfall organischer Materialien im [[Schlamm]] des [[Meeresgrund]]s. Unter Luftabschluss verbindet sich [[Schwefelwasserstoff]] mit [[Eisen]]verbindungen zu [[Pyrit]]-Konkretionen mit knolligem oder kugeligem Aussehen. Nach der Verdichtung des Schlamms zu tonigen [[Suspension (Chemie)|Sedimenten]] bleiben die Knollen im [[Gestein]] eingeschlossen, bis sie zu einem späteren Zeitpunkt durch [[Verwitterung]] wieder freigelegt werden, da sie verwitterungsresistenter als [[Tonstein]] sind. Hierbei wandelt sich die Pyritkonkretion durch Luft[[sauerstoff]] oberflächlich in [[Limonit]] um. Ähnlich wie Pyrit neigen auch Bojisteine im Laufe von Jahrzehnten bis Jahrhunderten durch die Aufnahme von [[Wasser]] und fortschreitende [[Oxidation]] zum Zerfall, was durch Sulfatausblühungen sichtbar wird.

Große Vorkommen mit Bojisteinen finden sich unter anderem bei [[Dongchuan]] in China und in den US-amerikanischen Bundesstaaten [[Kansas]], [[Nebraska]], [[North Dakota|North-]] und [[South Dakota]].

== Verwendung ==
Boji-Steine werden vor allem als [[Heilstein]]e genutzt. [[Esoterik]]er sehen in ihnen "Behältnisse von Energiezentren", die man durch "Streicheln" aktivieren kann. Eher eckige Bojis werden als "männliche" und eher glatte als "weibliche" Steine bezeichnet und bevorzugt zusammen angewendet.<ref>{{Literatur| Autor= Walter Schumann| Titel= Edelsteine und Schmucksteine. Alle Arten und Varietäten der Welt. 1600 Einzelstücke| Auflage= 13. überarbeitete und erweiterte | Verlag= BLV Verlag | Ort= München u. a. | Jahr= 2002 | Seiten= 284 | ISBN= 3-405-16332-3}}</ref>

== Siehe auch ==
* [[Liste der Minerale]]

== Einzelnachweise ==
<references />

== Weblinks ==
* [http://www.mineralienwissen.de/boji.html Information zum Bojistein auf www.mineralienwissen.de]
* [http://www.epigem.de/index.php/leistungen/namensuche.html EPI Institut für Edelsteinprüfung - Handelsnamen und was sie bedeuten] (Sucheingabe ''Boji'')

[[Kategorie:Varietät (Mineralogie)]]

MikroSim

2013-08-23T19:31:53Z

SimDoc:

{{Infobox Software
| Logo = [[Datei:MikroSim2010_Icon.jpg|miniatur|80px|zentriert|Logo von MikroSim 2010]]
| Screenshot =[[Datei:Screenshot_MikroSim2010.png|miniatur|250px|zentriert|Bildschirmfoto der Windows-Applikation MikroSim 2010]]
| AktuelleVersion = 3.0.13
| AktuelleVersionFreigabeDatum = 20.6.2012
| Entwickler = Martin Perner
| Hersteller = 0/1-SimWare
| Betriebssystem = [[Microsoft Windows|Windows]]
| Programmiersprache = Visual Basic
| Lizenz = [[Freeware]]/[[Shareware]]
| Deutsch = ja
| Website = [http://www.mikrocodesimulator.de www.mikrocodesimulator.de]
}}

Das Programm '''MikroSim''' ist eine [[Lernsoftware]] für das [[Betriebssystem]] [[Microsoft Windows]] zur hardware-unspezifischen Erläuterung der allgemeinen Funktionsweise und Steuerabläufe einer virtuellen Rechenmaschine. Es lassen sich in allgemein verständlicher Weise miniaturisierte [[Rechenwerk]]e didaktisch auf [[Registertransferebene]] erläutern, die in [[Mikrocontroller]]n, [[Prozessor (Hardware)|Prozessoren]], und [[Computer]]n ablaufen.

== Allgemeines ==
Anfänglich wurde MikroSim als Prozessor-Simulationssoftware konzipiert. Da MikroSim allerdings die Programmierbarkeit ([[Mikroprogrammierung]]) eines [[Mikroprogrammsteuerwerk]]s mittels [[Mikrobefehl]]en in den Vordergrund stellt, betont die Anwendung als [[Mikrocodesimulator]] den Aspekt der Mikrocodesimulation. In der gegenwärtigen Entwicklung erlangt der [[Simulator]] den Status einer virtuellen Applikation. Dabei werden allgemeine Prinzipien der System- und [[Rechnerarchitektur]] aufgegriffen, die sich mit dem Beginn des [[Informationszeitalter]]s etabliert haben und noch heute bestand haben, ohne sich auf spezielle Hardwareaspekte zu beschränken. Auf diese Weise erlangt das Simulationswerkzeug einen zeitlosen, freien didaktischen Nutzen, ohne sich auf spezielle vergangene und zukünftige Entwicklungen festzulegen. Die detaillierte Dokumentation und die zweisprachige Benutzerführung der [[E-Learning]]-Anwendung in Deutsch und Englisch, sowie die Auslegung der Software für die weithin verbreiteten Windows-Betriebssysteme, ist der Grund für den nachhaltigen Bestand der Software im Lehrbetrieb auf dem Gebiet der [[technische Informatik|technischen Informatik]] in Ausbildung und Lehre seit 1992.

== Entwicklungsgeschichte ==
Die Software basiert auf einer freien, unter [[Turbo-Pascal]] für das Betriebssystem [[MS-DOS]] geschriebenen Programmversion, die bis 1992 an der [[Philipps-Universität Marburg]] in der Vorlesung zur technischen Informatik für die Erläuterung von Mikrocodesteuerprozessen herangezogen wurde. Das bis dahin etablierte didaktische Vorlesungskonzept wurde im Sommer 1992 von Martin Perner während seines Physik-[[Diplom]]studiums (1990–1995) aufgegriffen und in freier Arbeit auf das Betriebssystem [[Microsoft Windows 3.x|Windows 3.1]] unter [[Visual Basic]] 1.0 portiert. Dabei entstand der Simulator in einer für damalige Verhältnisse völlig neuartigen Konzeption mit weitreichender Funktionalitätsverbesserung. Die Weiterentwicklung der Lehrsoftware unter Windows wurde bis 1995 von dem Fachbereich Mathematik/Informatik der Universität Marburg durch Heinz-Peter Gumm gefördert. Der Simulator wurde im November 1994 mit dem ''Europäischen Hochschul-Software-Preis 1994'' in der Kategorie [[Informatik]] in [[Heidelberg]] ausgezeichnet und im März 1995 auf der Computermesse [[CeBit]] in Hannover am Stand der hessischen Hochschulen der Öffentlichkeit vorgestellt.

Im Zeitraum Ende 1995 bis Anfang 2000 wurde der Simulator mit wenigen Verbesserungen unter der Revision MikroSim 1.2 veröffentlicht. In diesem Zeitraum wurde MikroSim im Rahmen des ''Europäischen Jahres des lebensbegleitenden Lernens 1996'' mit 1000 ECU prämiert, sowie beim Wettbewerb ''Multimedia Transfer'97'' im Rahmen der Messe ''LearnTec’97'' vorgestellt.<ref>[http://www.mikrocodesimulator.de/index.php#PreiseAuszeichnungen Preise und Auszeichnungen] auf der MikroSim-Website (Abgerufen am 5. November 2010.)</ref> In seiner vorletzten Neuauflage wurde der Simulator unter dem Namen „Mikrocodesimulator MikroSim2000“ mittels der Programmiersprache MS-Visual Basic 4.0 für [[Microsoft Windows 95|Windows 95]] angepasst.

Im Zeitraum Anfang 2008 bis 2009 erfuhr der Simulator weitreichende konzeptionelle Erweiterungen, ohne die Möglichkeiten der Mikrocodesimulation im Kern zu verändern. Dabei wird die Rechenleistung heutiger Windows-Applikationen und der verwendeten Hardware ausgenutzt, um Simulationen bis hin zur virtuellen Applikation zu ermöglichen.
MikroSim ist als 32-Bit-Version kompiliert und für [[Microsoft Windows XP|Windows XP]] optimiert worden. Das Programm ist auf allen 32- und 64-Bit-Betriebssystem der Versionen [[Microsoft Windows Vista| Windows Vista]] und [[Microsoft Windows 7|Windows 7]] ohne spezielle XP-Kompatibilitätsmodi ausführbar. Seit Januar 2010 wird der Simulator unter „Mikrocodesimulator MikroSim 2010“ von 0/1-SimWare vertrieben.

== Funktionsweise und -umfang ==
Das Programm ermöglicht den schrittweisen Aufbau einer virtuellen Applikation, die in ihrer Funktionalität unveränderbar vorgegeben ist. Im Erkundungsmodus kann die Funktionsweise und Steuerungsmöglichkeit neu hinzugefügter Komponenten innerhalb eines Mikrocode-Befehlszyklus in Erfahrung gebracht werden. Die Breite der von MikroSim unterstützten Mikrobefehle umfasst 49 Bit. Ein Mikrobefehl wird in drei Teilphasen eines 3-Phasentakts abgearbeitet. Die Teilphasen werden als Hol-, Rechen- und Bringphase bezeichnet und bewirken das Holen eines 32 Bit breiten Registerwerts, das Ausführen einer 32-Bit-Berechnung, und das abschließende Speichern des Rechenergebnisses in einem CPU-internen [[Register (Computer)|Register]].

Im Simulationsmodus können hintereinander ausgeführte Mikrobefehle die zentrale Recheneinheit des Simulators steuern, wobei jeder Mikrobefehl auf die Adresse des nächsten Mikrobefehls verweist. Der Mikrobefehlssatz, gemeinhin als „Mikrocode“ der Recheneinheit bezeichnet, umfasst in der gegenwärtigen Implementierung von MikroSim 1024 49-Bit-lange Mikrobefehle. Strukturierungsmöglichkeiten im adressierbaren Ablaufplan im Mikrocode und die Entwicklung eines zyklisch arbeitenden, mikrocodeprogrammierten [[Interpreter]]s für Operationscodes (kurz [[Opcode]]s) ermöglichen die Implementierung von einzelnen mikrocodeprogrammierten Mikrobefehlssequenzen. Diese können als mikroprogrammierte [[Maschinenbefehl]]e aufgefasst werden. Der Mikrocode kann als [[Firmware]] für MikroSim als Mikrocode-[[Read-Only Memory|ROM]]-Datei (ROM, engl. {{lang|en|Read-Only Memory}}) abgelegt, modifiziert und erneut geladen werden.

Innerhalb eines Mikrobefehlzyklus kann sowohl die CPU als auch ein Ein-Ausgabe-Kontroller auf einen externen 16 kB umfassenden [[Random-Access Memory|RAM]]-[[Datenspeicher]] (RAM, engl. {{lang|en|Random-Access Memory}}) zurückgreifen. Über den Ein-Ausgabe-Kontroller erfolgt die Kommunikation mit angeschlossenen Ein- und Ausgabekomponenten mit [[Direct Memory Access|DMA]]-, [[I2C|I2C]]- und [[Interrupt Request|IRQ]]-Funktionalität. Unterstützt werden ein Ausgabe-Port, eine Anzeige, ein Zeitgeber, ein Ereignis-Trigger, ein Digital-Analog-Wandler, eine Tastatur und Daten-Ein-Ausgabe-Kanäle.

Der Mikrocodesimulator verwendet acht frei verwendbare 32-Bit-Register, deren Inhalt für vorzeichenbehaftete und vorzeichenlose Ganzzahlberechnungen, sowie für 32-Bit-Gleitkommaarithmetik eingesetzt werden. Mit einem übersichtlichen Systemzahleditor können die Registerinhalte betrachtet und modifiziert werden.

Die zentrale Recheneinheit des Simulators, die 32-Bit-[[Arithmetisch-logische Einheit|ALU]], unterstützt 128 verschiedene, grundlegende Rechenoperationen für Ganzzahlen und Interrupt-Steuerung bis hin zur [[Gleitkommaarithmetik]], die als erstes in vergleichbarer Weise bereits von [[Konrad Zuse]] eingeführt wurde. Zur Verdeutlichung dieser Arithmetik stehen elementare Rechenoperationen für die schrittweise auflösbare Gleitkomma-Registeroperationen in Mantisse und Exponent von den Grundberechnungen Addition/Subtraktion und Multiplikation/Division zur Verfügung. Weiterführend werden darauf aufbauend mächtigere 32-Bit-Rechenbefehle der Gleitkommaarithmetik in Mantisse und Exponent für die [[Grundrechenart]]en und elementarer analytischer Funktionen bereitgestellt, wie sie in mathematischen [[Coprozessor]]en realisiert sind. Dabei wird idealisiert angenommen, dass jede der 128 unterstützten ALU-Rechenoperationen für die Ausführung nur einen virtuellen Rechentakt benötigt.

Die Mikrobefehle können auf verschiedenen Simulationsniveaus ausgeführt werden:
* In dem niedrigsten Simulationsniveau unterstützt der Simulator die phasenweise Abarbeitung eines Mikrobefehls, der in eine sogenannte Hol-, Rechen- und Bring-Phase unterteilt ist. Die Abarbeitung der Teilphasen ist mit einer einstellbaren Verzögerung zur besseren Nachverfolgung möglich.
* Darauf aufbauend ist die komplette Abarbeitung eines Mikrobefehls in einem Dreiphasen-Takt ohne Verzögerung möglich. Ebenso die Abarbeitung mehrerer zu einem Maschinenbefehl zusammenfassbarer Mikrobefehle mittels eines in Mikrocode programmierten Maschinencodeinterpreters. Der Interpreter hat die Aufgabe, Maschinensprachebefehle, als Operationscodes in einem Byte-Wert codiert, aus dem RAM zu holen und an die entsprechende Mikrocodeunterprogrammadresse zur mikroprogrammierten Ausführung zu verzweigen.
* Darüber hinaus ist die Abarbeitung mehrerer Maschinenbefehle bis zu einem frei definierbaren Haltepunkt möglich. Dabei kann die Zeit bis zum Erreichen des Halte-Punkts für Simulationsoptimierungen gestoppt werden.
* Im höchsten Simulationsniveau kann der Mikrocodesimulator im Freilauf-Modus ohne jegliche Unterbrechung Maschinensprachesequenzen abarbeiten und somit die Interaktion der Applikation mit Ein- und Ausgabeschnittstellen in den Vordergrund rücken.

Mit verschiedenen Zusatzoptionen können visuelle CPU-Aktivitäten zu Gunsten der Steigerung der Abarbeitungsgeschwindigkeit unterdrückt werden, so dass die Maschinenprogrammierung der virtuellen Applikation in den Vordergrund tritt.
Mit dem Performance-Index-Monitor bietet der Simulator die Möglichkeit, die Abarbeitungsgeschwindigkeit und Ausführungsdauer entworfener Mikrobefehl-Sequenzen zu bestimmen und diese in Bezug zur Rechenleistung, gemessen in Gleitkommaoperationen pro Sekunde (FLOPS, engl. {{lang|en|[[Floating Point Operations Per Second]]}}) und [[Instruktionen pro Sekunde|Maschinen-/Mikrobefehle pro Sekunde]] (MIPs, engl. {{lang|en|Million Instructions per Second}}), der verwendeten Simulationshardware zu setzen.

Mit dem Zusatzprogramm MikroBAT, dem sogenannten „Basic Assembler Tool“ für MikroSim, können einfache Programme in [[Assembler (Informatik)|Assembler]] erstellt werden. Dabei wird der Befehlsumfang unterstützter [[Mnemonic]]s durch den Satz eigener mikrocodeprogrammierter Maschinenbefehle (Opcode) bestimmt. Das Zusatzprogramm ist in der Lage, das Assembler-Programm in Maschinencodes zu übersetzen und in den externen Datenspeicher für anschließende Simulationen zu übertragen.
Zusammen mit MikroBAT behandelt der Mikrocodesimulator in didaktisch aufbauender Weise Lehraspekte der technischen Informatik vom schaltergesteuerten Rechenautomaten bis zur Assembler programmierbaren Applikation.

== Literatur ==
* H.P.Gumm, M.Sommer: ''Einführung in die Informatik'', 8. Auflage. Oldenbourg, München 2009, ISBN 978-3-486-58724-1, (Zu MikroSim insbesondere Kap. 5.6, S.470-485.)

== Weblinks ==
* [http://www.mikrocodesimulator.de Mikrocodesimulator MikroSim] – Offizielle Website

== Einzelnachweise ==
<references />

[[Kategorie:Virtualisierung]]
[[Kategorie:Lernsoftware]]
[[Kategorie:Rechnerarchitektur]]
[[Kategorie:Assembler]]
[[Kategorie:Technische Informatik]]

Intel HEX

2013-02-02T22:20:30Z

SimDoc:

Das '''Intel HEX'''-Format ist ein Datenformat zur Speicherung und Übertragung von [[Binärcode|binären]] Daten. Es wird heute hauptsächlich verwendet, um Programmierdaten für [[Mikrocontroller]] bzw. [[Mikroprozessor]]en, [[Erasable Programmable Read Only Memory|EPROMs]] und ähnliche Bausteine zu speichern. Es kann aber auch zur Speicherung von Lademodulen verwendet werden. Das HEX-Format ist das älteste Datenformat seiner Art und seit den 1970er Jahren in Gebrauch. Spätere Erweiterungen unterstützen speziell die segmentierte Adressierung der Intel-[[X86-Prozessor|80x86-Prozessoren]].

Ein '''Intel HEX'''-File liegt im [[ASCII]]-Format vor. Die Bytes der kodierten Binärdaten werden jeweils als [[Hexadezimalsystem|Hexadezimalzahl]] aus zwei ASCII-Zeichen (0...9 und A...F) dargestellt. HEX-Dateien können mit einem Texteditor geöffnet und modifiziert werden. Die HEX-Datei ist etwa doppelt so groß wie die enthaltenen Binärdaten. Die Datensätze sind mit einer [[Prüfsumme]] versehen, so dass Übertragungsfehler erkannt werden können.

== Geschichte ==
Das Intel-Hex Format (Ursprünglich '''Intellec-Hex''') wurde von Intel 1973 für die Intellec Entwicklungssysteme ([[MDS]]) entworfen um Programme von Lochstreifen zu laden und starten. Außerdem sollte es die Übermittlung der Daten zur ROM-Produktion vereinfachen. Gleichzeitig wurde es zur Programmierung von (E)PROM mittels lochstreifen- oder lochkartengesteuerter EPROM-Programmiergeräte verwendet. Ab der Einführung von Diskettenlaufwerken mit dem MCS Serie II unter ISIS II (1975) wurden auch Dateien in diesem Format erstellt. Als Dateiendung dient seitdem '''HEX'''.

== Format ==
Das hier beschriebene Format entspricht der ''Hexadecimal Object File Format Specification''<ref>''Hexadecimal Object File Format Specification'', Revision A vom 6. Januar 1988</ref> von Intel.

=== Aufbau eines Datensatzes ===
Die Codierung ist (7 Bit) ASCII. Jeder Datensatz wird durch einen Doppelpunkt (":") eingeleitet, besteht aus einer geraden Anzahl von Zeichen und wird durch ein Zeilenende abgeschlossen. Der Aufbau des Zeilenendes ist nicht definiert und Medienabhängig. Intel-Tools für Streaming-Medien erzeugen immer ein CR/LF (0D0AHEX).

Jeweils zwei Zeichen repräsentieren ein Datenbyte. Die Notation erfolgt hexadezimal, [[big-endian]] mit den Zeichen 0..9 und A..F, d.h. dass das höherwertige Halbbyte zuerst steht. Gleichfalls erfolgen alle Angaben in den Addressfeldern [[Big-Endian]]. Kleinbuchstaben (a..f) sind in der Definition nicht erwähnt, werden jedoch von den meisten Implementationen unterstützt.

{|class="prettytable"
|-
! Intel-Bezeichnung !! Inhalt !! Verwendung
|-
| RECORD MARK || Satzbeginn || ":" (Doppelpunkt, ASCII-Kodierung 3AHEX)
|-
| RECLEN || Datenlänge || Länge der Nutzdaten als zwei Hexadezimalziffern
|-
| LOAD OFFSET || Ladeadresse || [[Bit|16bit]]-Adresse (Big-Endian)
|-
| RECTYP || Satztyp || Datensatztyp (00..05)
|-
| INFO or DATA || Daten || Nutzdaten (RECLEN x 2 Zeichen)
|-
| CHKSUM || Prüfsumme || [[#Berechnung der Prüfsumme|Prüfsumme]] über den Datensatz (ohne Satzbegin)
|}

=== Datensatztypen ===
==== Übersicht ====
Es gibt sechs Datensatztypen (''record types''):

{|class="prettytable"
|-
! Typ !! Bezeichnung !! Verwendung
|-
| 00 || Data Record || Nutzdaten
|-
| 01 || End of File Record || Dateiende ( sowie Startadresse bei 8-Bit Daten)
|-
| 02 || Extended Segment Address Record || Segmentadresse für folgende Nutzdaten
|-
| 03 || Start Segment Address Record || Segmentierte Startadresse (CS:IP Register)
|-
| 04 || Extended Linear Address Record || Höherwertige 16 bit der Adresse für folgende Nutzdaten
|-
| 05 || Start Linear Address Record || Lineare Startadresse (EIP-Register)
|}

Die Datensätze können in beliebiger Reihenfolge vorkommen, ein Endesatz (Typ ''01'') beendet die Verarbeitung.

==== Data Record (Typ ''00'') ====
Der Datensatz enthält die 16bit-Adresse Ladeadresse und die Nutzdaten.

{| class="prettytable"
|-
| || Startcode || Anzahl der Bytes || align="center"|Adresse || align="center"|Typ || align="center"|Datenfeld || align="center"|Prüfsumme
|-
| Länge || align="center"|1 Zeichen || align="center"|2 Ziffern || align="center"|4 Ziffern || align="center"|2 Ziffern || align="center"|2''n'' Ziffern || align="center"|2 Ziffern
|-
| Inhalt || align="center"|: || align="center"|''n'' || align="center"|''Adresse'' || align="center"|00 || align="center"|''Daten'' || align="center"|''Prüfsumme''
|}

''n'': Anzahl der Bytes im Datenfeld 
''Adresse'': 16bit-Adresse für die Speicherung des Datensatzes 
''Daten'': Datenfeld, n Bytes 

==== End of File Record (Typ ''01'') ====
Der Datensatz markiert das Dateiende. In der ursprünglichen (8 Bit) Definition wird, für ladbare Formate, im Adressfeld die Startadresse des Programms (PC) angegeben. In den 16/32 Bit Formaten muss diese ''0000'' sein.

{| class="prettytable"
|-
| || Startcode || Anzahl der Bytes || align="center"|Adresse || align="center"|Typ || Prüfsumme
|-
| Länge || align="center"|1 Zeichen || align="center"|2 Ziffern || align="center"|4 Ziffern || align="center"|2 Ziffern || align="center"|2 Ziffern
|-
| Inhalt || align="center"|: || align="center"|00 || align="center"|0000 || align="center"|01 || align="center"|FF
|}

==== Extended Segment Address Record (Typ ''02'') ====
Der Datensatz enthält die Basisadresse des Speichersegmentes. Er wird verwendet, wenn der Umfang eines 16bit-Adressraumes (also 64kByte) nicht ausreicht. Die im Datensatz enthaltene Adresse wird mit 16 multipliziert und bei den folgenden ''data records'' (Typ ''00'') zu der dort enthaltenen 16bit-Adresse addiert. Bit 3..0 (niederwertigste Stelle) müssen immer Null sein. Das Adressfeld des Datensatzes vom Typ ''02'' ist immer 0000, die Länge ist ''02''.

{| class="prettytable"
|-
| || Startcode || Anzahl der Bytes || align="center"|Adresse || align="center"|Typ || align="center"|Datenfeld || align="center"|Prüfsumme
|-
| Länge || align="center"|1 Zeichen || align="center"|2 Ziffern || align="center"|4 Ziffern || align="center"|2 Ziffern || align="center"|4 Ziffern || align="center"|2 Ziffern
|-
| Inhalt || align="center"|: || align="center"|02 || align="center"|0000 || align="center"|02 || align="center"|''Segment'' || align="center"|''Prüfsumme''
|}

==== Start Segment Address Record (Typ ''03'') ====
Der Datensatz spezifiziert bei Lademodulen die Startadresse. Für x86 Prozessoren ist dies der CS:IP Inhalt. Der Datensatz kann an beliebiger Position auftauchen. Die Startadresse wird berechnet als ''Segment * 16 + Offset''. Das Adressfeld ist immer ''0000'', die Länge ist ''04''.

{| class="prettytable"
|-
| || Startcode || Anzahl der Bytes || align="center"|Adresse || align="center"|Typ || colspan="2" align="center"|Datenfeld || align="center"|Prüfsumme
|-
| Länge || align="center"|1 Zeichen || align="center"|2 Ziffern || align="center"|4 Ziffern || align="center"|2 Ziffern || align="center"|4 Ziffern || align="center"|4 Ziffern || align="center"|2 Ziffern
|-
| Inhalt || align="center"|: || align="center"|04 || align="center"|0000 || align="center"|03 || align="center"|''Segment'' || align="center"|''Offset'' || align="center"|''Prüfsumme''
|}

==== Extended Linear Address Record (Typ ''04'') ====
Zur Unterstützung eines 32 Bit Addressraums enthält das Datenfeld die höherwertigen 16 Bit (ULBA Upper Linear Base Address) einer 32-Bit-Adresse (LBA Linear Base Address). Die niederwertigen 16 Bit werden als ''0000'' angenommen. Die Adressermittlung der folgenden Typ ''00'' Datensätze erfolgt als ULBA+DRLO+DRI Modulo 2^32 (DRLO - DATA Record Load Offset (Adressfeld des Data Record Typ 0), DRI - Data Record Index (Byteposition des Data Record Typ 0)). Das Adressfeld ist immer ''0000'', die Länge ist ''02''.

{| class="prettytable"
|-
| || Startcode || Anzahl der Bytes || align="center"|Adresse || align="center"|Typ || align="center"|Datenfeld || align="center"|Prüfsumme
|-
| Länge || align="center"|1 Zeichen || align="center"|2 Ziffern || align="center"|4 Ziffern || align="center"|2 Ziffern || align="center"|4 Ziffern || align="center"|2 Ziffern
|-
| Inhalt || align="center"|: || align="center"|02 || align="center"|0000 || align="center"|04 || align="center"|''ULBA, Adresse (high word)'' || align="center"|''Prüfsumme''
|}

==== Start Linear Address Record (Typ ''05'') ====
Der Datensatz spezifiziert bei Lademodulen die Startadresse. Bei x86 Prozessoren ist dies der Inhalt des EIP-Registers. Das Adressfeld ist immer ''0000'', die Länge ist ''04''

{| class="prettytable"
|-
| || Start code || Anzahl der Bytes || align="center"|Adresse || align="center"|Typ || align="center"|Datenfeld || align="center"|Prüfsumme
|-
| Länge || align="center"|1 Zeichen || align="center"|2 Ziffern || align="center"|4 Ziffern || align="center"|2 Ziffern || align="center"|8 Ziffern || align="center"|2 Ziffern
|-
| Inhalt || align="center"|: || align="center"|04 || align="center"|0000 || align="center"|05 || align="center"|''EIP'' || align="center"|''Prüfsumme''
|}

=== Berechnung der Prüfsumme ===
Die Prüfsumme wird aus dem gesamten Datensatz ausschließlich des Startcodes und der Prüfsumme selbst berechnet. Der Datensatz wird byteweise summiert, von der Summe wird das niederwertige Byte genommen und davon wiederum das Zweierkomplement gebildet.

Das [[Zweierkomplement]] wird gebildet, indem man die Bits des niederwertigen Bytes invertiert und dann 1 addiert. Dies kann man z.B. durch die [[XOR-Verknüpfung|Exklusiv-Oder-Verknüpfung]] mit FFHEX und Addition von 01HEX erreichen. So bleibt 00HEX unverändert, aus 01HEX wird FEHEX u.s.w.

Das Zweierkomplement drückt im Binärsystem eine negative Zahl aus. Da die Prüfsumme damit die negative Summe der restlichen Bytes darstellt, gestaltet sich die Überprüfung eines Datensatzes auf Fehler sehr einfach. Man summiert einfach die einzelnen Bytes eines Datensatzes ''inklusive'' der Prüfsumme und erhält als niederwertiges Byte 00HEX, falls der Datensatz korrekt ist.

=== Varianten ===
==== Intel ====
Im Laufe der Prozessorentwicklung von der [[Intel 4004|4004]] bis heute wurden verschieden Varianten definiert:

{| class="prettytable"
|-
! Variante !! Einsatz !! Erlaubte Satztypen
|-
| valign="top"|I08HEX || valign="top"|4/8 Bit CPU (4004..8085) || 00 (Data), 01 (End of File)
|-
| valign="top"|I16HEX || valign="top"|16 Bit CPU (8086/186/286) || 00 (Data), 01 (End of File), 02 (Extended Segment Address), 03 (Start Segment Address)
|-
| valign="top"|I32HEX || valign="top"|32 Bit CPU (ab 80386) || 00 (Data), 01 (End of File), 02 (Extended Segment Address), 03 (Start Segment Address), 04 (Extended Linear Address), 05 (Start Linear Address)
|}

==== Andere Hersteller ====
Das HEX Format wurde als Quasi-Standard vielfältig verwendet. Dabei wurde die [[Byteorder]] im Datenfeld teilweise geändert. d.h. die Reihenfolge stimmt nicht mit der Adresslage überein.

== Beispiel ==
:020000021000EC
:10010000214601360121470136007EFE09D2190140
:100110002146017EB7C20001FF5F16002148011988
:10012000194E79234623965778239EDA3F01B2CAA7
:100130003F0156702B5E712B722B732146013421C7
:00000001FF
{{Farblegende|#FFFFCC|Startcode}}
{{Farblegende|#66FFCC|Byte count}}
{{Farblegende|#CCCCFF|Adresse}}
{{Farblegende|#9999FF|Typ}}
{{Farblegende|#CCFFFF|Datenfeld}}
{{Farblegende|#FF9999|Prüfsumme}}

Die Prüfsumme für den ersten Beispiel-Datensatz berechnet sich wie folgt:
<math>{ 10+01+00+00+21+46+01+36+01+21}</math>
<math>{+47+01+36+00+7E+FE+09+D2+19+01}\ {{=}}\ 3C0 \rightarrow C0 \rightarrow \neg C0 + 1\ {{=}}\ 40</math>.

== Verwandte Dateiformate ==
Sehr ähnlich ist das [[Motorola]]-S-Format (auch kurz [[S-Record]], SREC oder S19). Außerdem existieren für diesen Anwendungsbereich auch weitere Formate, wie der einfache [[Binärcode]] oder das [[JEDEC Solid State Technology Association|Jedec]]-Format.

== Quellen, Weblinks ==
* [http://www.piclist.com/techref/fileext/hex/intel.htm Intel HEX Format] (englisch)
* [http://www.sbprojects.com/knowledge/fileformats/intelhex.php SB-Projects: fileformats: intel hex] - sehr übersichtliche Darstellung (englisch)
* [http://www.bialix.com/intelhex/ IntelHex Project] - Python library for Intel HEX files manipulations

== Einzelnachweise ==
<references />

{{SORTIERUNG:Intel Hex}}

[[Kategorie:Datenformat]]

[[cs:Intel HEX]]
[[en:Intel HEX]]
[[es:Intel HEX]]
[[fr:HEX (Intel)]]
[[hu:Intel HEX]]
[[pl:Intel Hex]]
[[ru:Intel HEX]]

Diskussion:Mikrocode

2012-09-30T20:01:18Z

SimDoc: /* Defekter Weblink korrigiert */

== Microcode ==
In dem Satz „Der Mikrocode ist quasi die „Maschinensprache“ des Mikroprogrammsteuerwerks eines Rechenwerks.“I sollten die letzten zwei Worte „eines Rechenwerks“ weggelassen werden, denn das Mikroprogrammsteuerwerk gehört nicht zum Rechenwerk, sondern ist „sein gleichrangiger Partner“ innerhalb des Prozessors. Das Füllwort „quasi“ macht sich auch nicht gut. --[[Benutzer:Reseka|Reseka]] 17:25, 12. Okt. 2010 (CEST)

:Danke für dein zweites wertvolles Feedback. So sollte es nun stimmen. Da ich sehe, dass du dich sehr gut in der Begriffswelt rund um das Mikroprogrammieren auskennst, würde ich gerne wissen, ob du meine "scharfe" Formulierung mit mir teilst, dass der "Mikrocode" mit dem "Binärcode des Mikroprogramms" gleich gesetzt werden kann, ähnlich dem "Maschinencode" als "binärer Bytecode eines Maschinenprogramms". Ich finde es wichtig, eine klare Abgrenzung zwischen den gängigen Begriffen wie Mikrocode und Mikroprogramm zu ziehen. --[[Benutzer:SimDoc|SimDoc]] 19:52, 12. Okt. 2010 (CEST)

Der Artikel enthält Werbung für einen Microcodesimulator, welcher keine Relevanz bei der Erläuterung des Micrcodes besitzt. (''nicht [[Hilfe:Signatur|signierter]] Beitrag von'' [[Spezial:Beiträge/84.178.157.70|84.178.157.70]] ([[Benutzer Diskussion:84.178.157.70|Diskussion]]) 18:18, 26. Jul 2011 (CEST)) 
:Ich denke, dass die Software, die in u.a. als Referenz erwähnt ist, sehrwohl eine Relevanz bei der Erklärung der Aspekte rund um den Begriff Mikrocode darstellt. Warum soll eine nützliche Freeware nicht für alle Interessierten als Verweis angeführt werden, um das Thema verständlich durchleuchten zu können?--[[Benutzer:SimDoc|SimDoc]] 21:43, 26. Jul. 2011 (CEST)
::Das Programm ist mittlerweile Shareware.--[[Spezial:Beiträge/92.198.37.119|92.198.37.119]] 11:38, 13. Mär. 2012 (CET)
:: ... und ist sogar als freischaltbare Demoversion kostenlos und lizenzfrei verwendbar. --[[Spezial:Beiträge/93.104.89.181|93.104.89.181]] 22:47, 14. Mär. 2012 (CET)

Diskussion:Mikroprogramm

2012-09-30T20:00:34Z

SimDoc: /* Defekter Weblink korrigiert */

== Korrekturwünsche ==
* Was ist ein Steuerablaufplan? Ich würde einfach von „Ablauf“ sprechen. Plan klingt mehr nach Vorbereitung!? Hab im Moment auch kein besseres Wort.
* Das Mikroprogrammsteuerwerk befindet sich nicht im Rechenwerk, sondern „neben“ ihm (Prozessor = Steuerwerk + Rechenwerk).
* Statt Mikrobefehlsspeicher ist der Begriff Mikroprogrammspeicher üblicher.
* Es werden nicht nur integrierte Schaltkreise aktiviert/deaktiviert, sondern allgemein „logische Funktionseinheiten“.
* Mikroassembler kann, muss aber nicht sein (Ich habe früher selbst 130-Bit-Mikrobefehle per Hand aus 0 und 1 zusammengestellt). --[[Benutzer:Reseka|Reseka]] 17:45, 12. Okt. 2010 (CEST)
::Danke für dein wertvolles und berechtigtes Feedback. Bitte schaue mal kurz drüber ob es so jetzt passt?--[[Benutzer:SimDoc|SimDoc]] 19:28, 12. Okt. 2010 (CEST)
:::In „von integrierten logischen Funktionseinheiten“ hätte ich gern das „integrierten“ raus, denn Mikroprogramme gab es schon als noch gar nicht an integrierte Schaltkreise zu denken war. Bei „um den begrenzt“ sollte das „um“ raus (Ausdruck). --[[Benutzer:Reseka|Reseka]] 20:10, 13. Okt. 2010 (CEST)
::::Einverstanden - so gefällt es mir!--[[Benutzer:SimDoc|SimDoc]] 08:58, 14. Okt. 2010 (CEST)

Mikrocode

2012-09-30T17:19:43Z

SimDoc: Link-Update

Der '''Mikrocode''' ist der [[Binärcode]] eines [[Mikrobefehl]]s oder einer Mikrobefehlssequenz eines [[Mikroprogramm]]s. Der Mikrocode kann als „[[Maschinensprache]]“ des [[Mikroprogrammsteuerwerk]]s zum Steuern des [[Rechenwerk]]s in einem [[Prozessor (Hardware)|Prozessor]] angesehen werden. In der Realität erlauben einige Prozessoren zum Zeitpunkt der [[Initialisierung]] das Überschreiben des bei der Fertigung festgelegten und in einem [[Festwertspeicher]] (Mikroprogrammspeicher) abgelegten Mikrocodes. Üblicherweise erfolgt dies durch Nachladen eines im EPROM-BIOS gespeicherten Mikrocodes. In diesem Fall bleibt der nachgeladene Mikrocode bis zum Abschalten des Prozessors erhalten, d. h. die [[Mikroprogrammierung]] ist reversibel. Ein Mikrocode-Update ist in aller Regel mit einem BIOS-Update verbunden.

Die Erzeugung von Mikrocode zur Steuerung einer virtuellen Recheneinheit wird mit dem Mikrocodesimulator [[MikroSim]] auf didaktische Weise vermittelt.

== Literatur ==
*{{Literatur | Autor= H. P. Gumm, M.Sommer | Titel=Einführung in die Informatik | Verlag=Oldenbourg|Auflage=8.|Jahr=2009 |ISBN=978-3-486-58724-1}}
*{{Literatur | Autor= K. Wüst| Titel=Mikroprozessortechnik: Grundlagen, Architekturen und Programmierung von Mikroprozessoren, Mikrocontrollern und Signalprozessoren | Verlag=Vieweg+Teubner Verlag|Auflage=3.|Jahr=2008 |ISBN=978-3-834-80461-7}}
*{{Literatur | Autor= H. Bähring| Titel=Mikrorechner-Technik, Band 1, Mikroprozessoren und Digitale Signalprozessoren | Verlag=Springer|Auflage=3.|Jahr=2002 |ISBN=3-540-41648-x}}
*{{Literatur | Autor= H. Bähring| Titel=Mikrorechner-Technik, Band 2, Busse, Speicher, Peripherie und Mikrocontroller| Verlag=Springer|Auflage=3.|Jahr=2002 |ISBN=3-540-43693-6}}
*{{Literatur | Autor= Uwe Brinkschulte, Theo Ungerer| Titel=Mikrocontroller und Mikroprozessoren| Verlag=Springer |Jahr=2002 |ISBN=3-540-43095-4}}

== Weblinks ==
*{{cite web|url=http://www.mikrocodesimulator.de/ |title=Mikrocodesimulator MikroSim 2010 |publisher=0/1-SimWare |date= |accessdate=2010-10-03}}
*{{cite web|url=http://www.stéen.se/share/unix/kernel/microcode/microcode.pdf
|title=P6 Family Processor Microcode Update, Feature Review |publisher=J. Molina, W. Arbaugh |year=2000 |accessdate=2010-10-03}}
*{{cite web|url=http://www.cs.clemson.edu/~mark/uprog.html
|title=A Brief History of Microprogramming|publisher=M. Smotherman |year=2010 |accessdate=2010-10-03}}
*{{cite web|url=http://research.microsoft.com/en-us/um/people/gbell/Computer_Structures_Principles_and_Examples/csp0167.htm
|title=Computer Structures: Principles and Examples, Part 2, REGIONS OF COMPUTER SPACE, Section 1, MICROPROGRAM-BASED PROCESSORS, Seite 151 ff. |publisher=McGraw-Hill Computer Science Series |accessdate=2010-10-03}}
*{{cite web|url=http://www.intel.com/Assets/PDF/manual/253668.pdf |title=Intel(R) 64 and IA-32 Architectures Software Developer’s Manual, Volume 3A: System Programming Guide, Part 1, Chapter 9.11: "Microcode update facilities"|publisher=Intel Cooperation |date=December 2009 |accessdate=2010-10-03}}
*{{cite web|url=https://fedorahosted.org/microcode_ctl/#|title=Intel Microcode Update Utility|accessdate=2012-09-30}}
*{{cite web|url=http://support.microsoft.com/kb/936357 |title=A microcode reliability update is available that improves the reliability of systems that use Intel processors|Microsoft|accessdate=2010-10-03}}
*{{cite web|url=http://www.intel.com/support/motherboards/server/sb/cs-021619.htm| title=BIOS Update required when Missing Microcode message is seen during POST |publisher=Intel Cooperation |accessdate=2010-10-03}}

[[Kategorie:Programmierbare Logik]]
[[Kategorie:Rechnerarchitektur]]
[[Kategorie:Firmware]]
[[Kategorie:Technische Informatik]]

[[ca:Microcodi]]
[[en:Microcode]]
[[es:Microcódigo]]
[[nl:Microcode]]
[[simple:Microcode]]

Mikroprogramm

2012-09-30T17:17:54Z

SimDoc: Link-Update

Das '''Mikroprogramm''' ist der Algorithmus eines [[Mikroprogrammsteuerwerk]]s in einem [[Prozessor]] zum Steuern seines [[Rechenwerk]]s. Mikroprogramme werden mittels [[Mikroprogrammierung]] erstellt. Dazu werden [[Mikrobefehl]]e eines Mikroprogramms in einer adressierbaren Reihenfolge angeordnet und in einem [[Festwertspeicher]], dem sog. [[Mikroprogrammspeicher]], bereitgestellt. Die Mikrobefehle enthalten in binärer Form codierte Anweisungen mit fester Bit-Anzahl zur Aktivierung und Deaktivierung logischer Funktionseinheiten. Auf diese Weise bestimmt das Mikroprogrammsteuerwerk mit Hilfe des Mikroprogramms, welche Schaltvorgänge in welcher Reihenfolge zur Umsetzung von Maschinenbefehlen für ein Rechenwerk benötigt werden. Unter Umständen werden Schaltvorgänge nicht in vollem Umfang unmittelbar durch den Mikrocode initiiert, sondern durch nachgeordnete [[Nanoprogramm]]e, die als [[Nanocode]] realisiert sind. Die Gesamtheit aller im Mikroprogrammspeicher binär codierten Mikrobefehle bilden den [[Mikrocode]].

Zusätzlich enthalten die [[Mikrobefehl]]e eine inhärent codierte Adressierungsvorschrift, mit deren Hilfe die Position des nächsten anzusteuernden Mikrobefehls zur taktweisen, zyklischen Abarbeitung des Steuerablaufplans berechnet werden kann. Auf diese Weise ist es möglich, Mikrobefehle im Mikroprogramm nicht nur in aufsteigender Adressreihenfolge mit einfacher Sprungweite auszuführen, sondern ebenso in Adressierungssequenzen, die absolute, relative und bedingte Adressierungssprünge beinhalten können. Somit besteht die Möglichkeit einer möglichst redundanzfreien Strukturierung des Ablaufplans bzgl. sich wiederholender Mikrobefehlssequenzen. Somit besteht die Möglichkeit den begrenzt vorhandenen Mikrobefehlsspeicher in einer CPU für die Programmierung von Maschinenbefehlen in der Steuersprache der Mikrobefehle möglichst effektiv zu nutzen.

Das Mikroprogramm kann unmittelbar in Form binär codierter Mikrobefehle erstellt werden. Aber auch Hilfsmittel wie Mikroassembler können zur Mikroprogrammierung herangezogen werden, um die Steueranweisungen der Mikrobefehle eines Mikrocodeprogramms aus einer lesbaren Darstellung in die unübersichtliche binäre Mikrobefehlsform automatisiert zu übersetzen. Gleichzeitig kann mit dem [[Mikroassembler]] der Mikroprogrammspeicherinhalt und die inhärent codierte Adressierungsreihenfolge einer programmierten Mikrobefehlssequenz flexibel verwaltet werden. Die Erstellung eines Mikroprogramms zur Steuerung einer virtuellen Recheneinheit wird mit dem [[Mikrocodesimulator]] [[MikroSim]] auf didaktische Weise vermittelt.

== Literatur ==
*{{cite book | author= H.P. Gumm, M. Sommer | title=Einführung in die Informatik | publisher=Oldenbourg, 8. Auflage |year=2009 |isbn=978-3-486-58724-1}}
*{{cite book | author= K. Wüst| title=Mikroprozessortechnik: Grundlagen, Architekturen und Programmierung von Mikroprozessoren, Mikrocontrollern und Signalprozessoren | publisher=Vieweg+Teubner Verlag, 3. Auflage |year=2008 |isbn=978-3-834-80461-7}}
*{{cite book | author= H. Bähring| title=Mikrorechner-Technik, Band 1, Mikroprozessoren und Digitale Signalprozessoren | publisher=Springer, 3. Auflage |year=2002 |isbn=3-540-41648-x}}
*{{cite book | author= H. Bähring| title=Mikrorechner-Technik, Band 2, Busse, Speicher, Peripherie und Mikrocontroller| publisher=Springer, 3. Auflage |year=2002 |isbn=3-540-43693-6}}
*{{cite book | author= Bringschulte, Ungerer| title=Mikrocontroller und Mikroprozessoren| publisher=Springer |year=2002 |isbn=3-540-43095-4}}

== Weblinks ==
*{{cite web|url=http://www.mikrocodesimulator.de/ |title=Mikrocodesimulator MikroSim 2010 |publisher=0/1-SimWare |date= |accessdate=2010-10-03}}
*{{cite web|url=http://www.stéen.se/share/unix/kernel/microcode/microcode.pdf
|title=P6 Family Processor Microcode Update, Feature Review |publisher=J. Molina, W. Arbaugh |year=2000 |accessdate=2010-10-03}}
*{{cite web|url=http://www.cs.clemson.edu/~mark/uprog.html
|title=A Brief History of Microprogramming|publisher=M. Smotherman |year=2010 |accessdate=2010-10-03}}
*{{cite web|url=http://research.microsoft.com/en-us/um/people/gbell/Computer_Structures_Principles_and_Examples/csp0167.htm
|title=Computer Structures: Principles and Examples, Part 2, REGIONS OF COMPUTER SPACE, Section 1, MICROPROGRAM-BASED PROCESSORS, Seite 151 ff. |publisher=McGraw-Hill Computer Science Series |accessdate=2010-10-03}}
*{{cite web|url=http://www.intel.com/Assets/PDF/manual/253668.pdf |title=Intel(R) 64 and IA-32 Architectures Software Developer’s Manual, Volume 3A: System Programming Guide, Part 1, Chapter 9.11: "Microcode update facilities"|publisher=Intel Cooperation |date=December 2009 |accessdate=2010-10-03}}
*{{cite web|url=https://fedorahosted.org/microcode_ctl/#|title=Intel Microcode Update Utility|accessdate=2012-09-30}}
*{{cite web|url=http://support.microsoft.com/kb/936357 |title=A microcode reliability update is available that improves the reliability of systems that use Intel processors|Microsoft|accessdate=2010-10-03}}
*{{cite web|url=http://www.intel.com/support/motherboards/server/sb/cs-021619.htm| title=BIOS Update required when Missing Microcode message is seen during POST |publisher=Intel Cooperation |accessdate=2010-10-03}}

[[Kategorie:Systemsoftware]]
[[Kategorie:Rechnerarchitektur]]
[[Kategorie:Firmware]]
[[Kategorie:Technische Informatik]]

[[bs:Mikroprogram]]
[[en:Microprogram]]
[[fr:Microprogrammation]]
[[hr:Mikroprogramiranje]]
[[it:Microprogrammazione]]
[[pl:Mikroprogram]]
[[sh:Mikroprogramiranje]]
[[sr:Микропрограм]]
[[sv:Mikroprogram]]
[[tr:Mikroprogramlama]]

Mikroprogrammierung

2012-09-30T17:15:58Z

SimDoc: Link-Update

Als '''Mikroprogrammierung''' wird die Methode und das Vorgehen verstanden Schalt-, Rechen- und Steuerabläufe in einem [[Rechenwerk]], insbesondere einem integrierten Rechenwerk ([[Mikrocontroller]], [[Mikroprozessor]]) unterhalb der Ausführungsebene von [[Maschinenbefehl]]en auf Mikrobefehlsebene festzulegen und zu regeln. Als Mikroprogrammierung kann die Erstellung eines Mikrobefehlssatzes als Abfolge von Mikrobefehlsequenzen in einer Art Steuersprache für Schalter verstanden werden. Vereinzelt wird durch den Begriff ''Mikrocode-Programmierung oder Mikrocodeprogrammierung'' die Erstellung des sogenannten [[Mikrocode]]s bei der Mikroprogrammierung betont, der die Binärform des Mikrobefehlssatzes darstellt.

Mit der Mikrocodeprogrammierbarkeit eines Rechenwerks ist das Vorhandensein eines dazu angepassten [[Mikroprogrammsteuerwerk]]s verbunden, welches durch die taktweise Abfolge der Mikrocodebefehlssequenz gesteuert wird. Die Möglichkeit einer flexibel programmierbaren Abfolgesteuerung von Mikrobefehlen setzt voraus, dass in jedem [[Mikrobefehl]] (engl. ''Micro Instruction'') selbst eine Berechnungsvorschrift zum Verweis, d. h. [[Adressierung (Datenverarbeitung)|Adressierung]], auf den nächsten anzusteuernden Mikrobefehl enthalten ist.

Üblicherweise ist ein Maschinensprachebefehlssatz eines [[Prozessor (Hardware)|Prozessors]] bei der Fertigung (z. B aus Kompatibilitätsgründen) vorgegeben und nicht veränderbar. Der den Maschinencode bildende Mikrobefehlssatz (kurz Mikrocode) ist in einem [[Festwertspeicher]] wie [[EPROM]] oder [[ROM]] inner- oder außerhalb des Rechenwerks untergebracht und wird ggf. bei der [[Initialisierung]] des Rechenwerks in das Mikroprogrammsteuerwerk geladen. Zur Optimierung von Schaltungsabläufen werden dennoch Möglichkeiten vorgesehen und Vorkehrungen getroffen, dass ein Mikrocode korrigiert, verbessert oder angepasst werden kann, um kostspielige Neuentwürfe im Sinne eines Mikrocode-[[Bugfix]] zu umgehen. In den Anfängen der Mikroprozessor-Ära war die Möglichkeit einer flexiblen Mikrocodeprogrammierung unumgänglich und gewünscht, um einzelne zu einem Baustein-Neuentwurf führende Implementierungsfehler zu verhindern. Mit den Fortschritten in der [[Verifikation]] und Integrierbarkeit digitaler Schaltungen schien der Aspekt der Umprogrammierbarkeit einige Zeit lang an Bedeutung zu verlieren.

Dennoch hat das Interesse an der Umprogrammierbarkeit im Laufe der letzten Jahre eine Wiederbelebung erfahren. So sind Mikroprozessoren der Firma Intel ab dem Modell Pentium Pro (P6) im Mikrocode umprogrammierbar. Der als [[FDIV-Bug]] bekannt gewordene Rechenfehler auf einem Teil der Intel Pentium-P5-Prozessoren konnte hingegen nicht durch Mikrocodeprogrammierung behoben werden sondern nur durch Prozessoraustausch. Mit der Mikrocodeprogrammierung ist die Möglichkeit gegeben, Rechensteuerwerke mittels Mikrocode-[[Update]]s für spezielle Betriebssysteme zu optimieren.

Das Vorgehen bei der Programmierung im Sinne der Zusammenstellung der Mikrobefehle zu einem Mikroprogramm wird im englischsprachigen Raum als ''Microcoding'' bezeichnet. Dabei werden Programmierwerkzeuge verwendet, die als [[Mikroassembler]] (engl. ''Microassembler'') bezeichnet werden. Mit diesen Hilfsmitteln ist es möglich, auf übersichtliche Weise Mikrobefehlssequenzen zu verwalten und diese in Binärcode zu übersetzen. Die Lernsoftware [[Mikrocodesimulator]] [[MikroSim]] vermittelt auf didaktische Weise die Bedeutung und das praktische Vorgehen bei der Mikroprogrammierung einer virtuellen Recheneinheit.

== Literatur ==
*{{cite book | author= H.P. Gumm, M. Sommer | title=Einführung in die Informatik | publisher=Oldenbourg, 8. Auflage |year=2009 |isbn=978-3-486-58724-1}}
*{{cite book | author= K. Wüst| title=Mikroprozessortechnik: Grundlagen, Architekturen und Programmierung von Mikroprozessoren, Mikrocontrollern und Signalprozessoren | publisher=Vieweg+Teubner Verlag, 3. Auflage |year=2008 |isbn=978-3-834-80461-7}}
*{{cite book | author= H. Bähring| title=Mikrorechner-Technik, Band 1, Mikroprozessoren und Digitale Signalprozessoren | publisher=Springer, 3. Auflage |year=2002 |isbn=3-540-41648-x}}
*{{cite book | author= H. Bähring| title=Mikrorechner-Technik, Band 2, Busse, Speicher, Peripherie und Mikrocontroller| publisher=Springer, 3. Auflage |year=2002 |isbn=3-540-43693-6}}
*{{cite book | author= Bringschulte, Ungerer| title=Mikrocontroller und Mikroprozessoren| publisher=Springer |year=2002 |isbn=3-540-43095-4}}

== Weblinks ==
*{{cite web|url=http://www.mikrocodesimulator.de/ |title=Mikrocodesimulator MikroSim 2010 |publisher=0/1-SimWare |date= |accessdate=2010-10-03}}
*{{cite web|url=http://www.stéen.se/share/unix/kernel/microcode/microcode.pdf
|title=P6 Family Processor Microcode Update, Feature Review |publisher=J. Molina, W. Arbaugh |year=2000 |accessdate=2010-10-03}}
*{{cite web|url=http://www.cs.clemson.edu/~mark/uprog.html
|title=A Brief History of Microprogramming|publisher=M. Smotherman |year=2010 |accessdate=2010-10-03}}
*{{cite web|url=http://research.microsoft.com/en-us/um/people/gbell/Computer_Structures_Principles_and_Examples/csp0167.htm
|title=Computer Structures: Principles and Examples, Part 2, REGIONS OF COMPUTER SPACE, Section 1, MICROPROGRAM-BASED PROCESSORS, Seite 151 ff. |publisher=McGraw-Hill Computer Science Series |accessdate=2010-10-03}}
*{{cite web|url=http://www.intel.com/Assets/PDF/manual/253668.pdf |title=Intel(R) 64 and IA-32 Architectures Software Developer’s Manual, Volume 3A: System Programming Guide, Part 1, Chapter 9.11: "Microcode update facilities"|publisher=Intel Cooperation |date=December 2009 |accessdate=2010-10-03}}
*{{cite web|url=https://fedorahosted.org/microcode_ctl/# |title=Intel Microcode Update Utility|accessdate=2012-09-30}}
*{{cite web|url=http://support.microsoft.com/kb/936357 |title=A microcode reliability update is available that improves the reliability of systems that use Intel processors|Microsoft|accessdate=2010-10-03}}
*{{cite web|url=http://www.intel.com/support/motherboards/server/sb/cs-021619.htm| title=BIOS Update required when Missing Microcode message is seen during POST |publisher=Intel Cooperation |accessdate=2010-10-03}}

[[Kategorie:Systemsoftware]]
[[Kategorie:Rechnerarchitektur]]
[[Kategorie:Firmware]]
[[Kategorie:Technische Informatik]]

[[en:Microprogramming]]
[[fr:Microprogrammation]]
[[hr:Mikroprogramiranje]]
[[it:Microprogrammazione]]
[[sh:Mikroprogramiranje]]

MikroSim

2012-07-03T21:45:41Z

SimDoc: Icon und Screenshot eingebunden

{{Infobox Software
| Logo = [[Datei:MikroSim2010_Icon.jpg|miniatur|80px|zentriert|Logo von MikroSim 2010]]
| Screenshot =[[Datei:Screenshot_MikroSim2010.png|miniatur|250px|zentriert|Bildschirmfoto der Windows-Applikation MikroSim 2010]]
| AktuelleVersion = 3.0.13
| AktuelleVersionFreigabeDatum = 20.6.2012
| Entwickler = Martin Perner
| Hersteller = 0/1-SimWare
| Betriebssystem = [[Microsoft Windows|Windows]]
| Programmiersprache = Visual Basic
| Lizenz = FreeWare/ShareWare
| Deutsch = ja
| Website = [http://www.mikrocodesimulator.de www.mikrocodesimulator.de]
}}

Das Programm '''MikroSim''' ist eine [[Lernsoftware]] für das [[Betriebssystem]] [[Microsoft Windows]] zur hardware-unspezifischen Erläuterung der allgemeinen Funktionsweise und Steuerabläufe einer virtuellen Rechenmaschine. Es lassen sich in allgemein verständlicher Weise miniaturisierte [[Rechenwerk]]e didaktisch auf [[Registertransferebene]] erläutern, die in [[Mikrocontroller]]n, [[Prozessor (Hardware)|Prozessoren]], und [[Computer]]n ablaufen.

== Allgemeines ==
Anfänglich wurde MikroSim als Prozessor-Simulationssoftware konzipiert. Da MikroSim allerdings die Programmierbarkeit ([[Mikroprogrammierung]]) eines [[Mikroprogrammsteuerwerk]]s mittels [[Mikrobefehl]]en in den Vordergrund stellt, betont die Anwendung als [[Mikrocodesimulator]] den Aspekt der Mikrocodesimulation. In der gegenwärtigen Entwicklung erlangt der [[Simulator]] den Status einer virtuellen Applikation. Dabei werden allgemeine Prinzipien der System- und [[Rechnerarchitektur]] aufgegriffen, die sich mit dem Beginn des [[Informationszeitalter]]s etabliert haben und noch heute bestand haben, ohne sich auf spezielle Hardwareaspekte zu beschränken. Auf diese Weise erlangt das Simulationswerkzeug einen zeitlosen, freien didaktischen Nutzen, ohne sich auf spezielle vergangene und zukünftige Entwicklungen festzulegen. Die detaillierte Dokumentation und die zweisprachige Benutzerführung der [[E-Learning]]-Anwendung in Deutsch und Englisch, sowie die Auslegung der Software für die weithin verbreiteten Windows-Betriebssysteme, ist der Grund für den nachhaltigen Bestand der Software im Lehrbetrieb auf dem Gebiet der [[technische Informatik|technischen Informatik]] in Ausbildung und Lehre seit 1992.

== Entwicklungsgeschichte ==
Die Software basiert auf einer freien, unter [[Turbo-Pascal]] für das Betriebssystem [[MS-DOS]] geschriebenen Programmversion, die bis 1992 an der [[Philipps-Universität Marburg]] in der Vorlesung zur technischen Informatik für die Erläuterung von Mikrocodesteuerprozessen herangezogen wurde. Das bis dahin etablierte didaktische Vorlesungskonzept wurde im Sommer 1992 von Martin Perner während seines Physik-[[Diplom]]studiums (1990–1995) aufgegriffen und in freier Arbeit auf das Betriebssystem [[Microsoft Windows 3.x|Windows 3.1]] unter [[Visual Basic]] 1.0 portiert. Dabei entstand der Simulator in einer für damalige Verhältnisse völlig neuartigen Konzeption mit weitreichender Funktionalitätsverbesserung. Die Weiterentwicklung der Lehrsoftware unter Windows wurde bis 1995 von dem Fachbereich Mathematik/Informatik der Universität Marburg durch Heinz-Peter Gumm gefördert. Der Simulator wurde im November 1994 mit dem ''Europäischen Hochschul-Software-Preis 1994'' in der Kategorie [[Informatik]] in [[Heidelberg]] ausgezeichnet und im März 1995 auf der Computermesse [[CeBit]] in Hannover am Stand der hessischen Hochschulen der Öffentlichkeit vorgestellt.

Im Zeitraum Ende 1995 bis Anfang 2000 wurde der Simulator mit wenigen Verbesserungen unter der Revision MikroSim 1.2 veröffentlicht. In diesem Zeitraum wurde MikroSim im Rahmen des ''Europäischen Jahres des lebensbegleitenden Lernens 1996'' mit 1000 ECU prämiert, sowie beim Wettbewerb ''Multimedia Transfer'97'' im Rahmen der Messe ''LearnTec’97'' vorgestellt.<ref>[http://www.mikrocodesimulator.de/index.php#PreiseAuszeichnungen Preise und Auszeichnungen] auf der MikroSim-Website (Abgerufen am 5. November 2010.)</ref> In seiner vorletzten Neuauflage wurde der Simulator unter dem Namen „Mikrocodesimulator MikroSim2000“ mittels der Programmiersprache MS-Visual Basic 4.0 für [[Microsoft Windows 95|Windows 95]] angepasst.

Im Zeitraum Anfang 2008 bis 2009 erfuhr der Simulator weitreichende konzeptionelle Erweiterungen, ohne die Möglichkeiten der Mikrocodesimulation im Kern zu verändern. Dabei wird die Rechenleistung heutiger Windows-Applikationen und der verwendeten Hardware ausgenutzt, um Simulationen bis hin zur virtuellen Applikation zu ermöglichen.
MikroSim ist als 32-Bit-Version kompiliert und für [[Microsoft Windows XP|Windows XP]] optimiert worden. Das Programm ist auf allen 32- und 64-Bit-Betriebssystem der Versionen [[Microsoft Windows Vista| Windows Vista]] und [[Microsoft Windows 7|Windows 7]] ohne spezielle XP-Kompatibilitätsmodi ausgeführbar. Seit Januar 2010 wird der Simulator unter „Mikrocodesimulator MikroSim 2010“ von 0/1-SimWare vertrieben.

== Funktionsweise und -umfang ==
Das Programm ermöglicht den schrittweisen Aufbau einer virtuellen Applikation, die in ihrer Funktionalität unveränderbar vorgegeben ist. Im Erkundungsmodus kann die Funktionsweise und Steuerungsmöglichkeit neu hinzugefügter Komponenten innerhalb eines Mikrocode-Befehlszyklus in Erfahrung gebracht werden. Die Breite der von MikroSim unterstützten Mikrobefehle umfasst 49 Bit. Ein Mikrobefehl wird in drei Teilphasen eines 3-Phasentakts abgearbeitet. Die Teilphasen werden als Hol-, Rechen- und Bringphase bezeichnet und bewirken das Holen eines 32 Bit breiten Registerwerts, das Ausführen einer 32-Bit-Berechnung, und das abschließende Speichern des Rechenergebnisses in einem CPU-internen [[Register (Computer)|Register]].

Im Simulationsmodus können hintereinander ausgeführte Mikrobefehle die zentrale Recheneinheit des Simulators steuern, wobei jeder Mikrobefehl auf die Adresse des nächsten Mikrobefehls verweist. Der Mikrobefehlssatz, gemeinhin als „Mikrocode“ der Recheneinheit bezeichnet, umfasst in der gegenwärtigen Implementierung von MikroSim 1024 49-Bit-lange Mikrobefehle. Strukturierungsmöglichkeiten im adressierbaren Ablaufplan im Mikrocode und die Entwicklung eines zyklisch arbeitenden, mikrocodeprogrammierten [[Interpreter]]s für Operationscodes (kurz [[Opcode]]s) ermöglichen die Implementierung von einzelnen mikrocodeprogrammierten Mikrobefehlssequenzen. Diese können als mikroprogrammierte [[Maschinenbefehl]]e aufgefasst werden. Der Mikrocode kann als [[Firmware]] für MikroSim als Mikrocode-[[Read-Only Memory|ROM]]-Datei (ROM, engl. {{lang|en|Read-Only Memory}}) abgelegt, modifiziert und erneut geladen werden.

Innerhalb eines Mikrobefehlzyklus kann sowohl die CPU als auch ein Ein-Ausgabe-Kontroller auf einen externen 16 kB umfassenden [[Random-Access Memory|RAM]]-[[Datenspeicher]] (RAM, engl. {{lang|en|Random-Access Memory}}) zurückgreifen. Über den Ein-Ausgabe-Kontroller erfolgt die Kommunikation mit angeschlossenen Ein- und Ausgabekomponenten mit [[Direct Memory Access|DMA]]-, [[I2C|I2C]]- und [[Interrupt Request|IRQ]]-Funktionalität. Unterstützt werden ein Ausgabe-Port, eine Anzeige, ein Zeitgeber, ein Ereignis-Trigger, ein Digital-Analog-Wandler, eine Tastatur und Daten-Ein-Ausgabe-Kanäle.

Der Mikrocodesimulator verwendet acht frei verwendbare 32-Bit-Register, deren Inhalt für vorzeichenbehaftete und vorzeichenlose Ganzzahlberechnungen, sowie für 32-Bit-Gleitkommaarithmetik eingesetzt werden. Mit einem übersichtlichen Systemzahleditor können die Registerinhalte betrachtet und modifiziert werden.

Die zentrale Recheneinheit des Simulators, die 32-Bit-[[Arithmetisch-logische Einheit|ALU]], unterstützt 128 verschiedene, grundlegende Rechenoperationen für Ganzzahlen und Interrupt-Steuerung bis hin zur [[Gleitkommaarithmetik]], die als erstes in vergleichbarer Weise bereits von [[Konrad Zuse]] eingeführt wurde. Zur Verdeutlichung dieser Arithmetik stehen elementare Rechenoperationen für die schrittweise auflösbare Gleitkomma-Registeroperationen in Mantisse und Exponent von den Grundberechnungen Addition/Subtraktion und Multiplikation/Division zur Verfügung. Weiterführend werden darauf aufbauend mächtigere 32-Bit-Rechenbefehle der Gleitkommaarithmetik in Mantisse und Exponent für die Grundrechenarten und elementarer analytischer Funktionen bereitgestellt, wie sie in mathematischen [[Coprozessor]]en realisiert sind. Dabei wird idealisiert angenommen, dass jede der 128 unterstützten ALU-Rechenoperationen für die Ausführung nur einen virtuellen Rechentakt benötigt.

Die Mikrobefehle können auf verschiedenen Simulationsniveaus ausgeführt werden:
* In dem niedrigsten Simulationsniveau unterstützt der Simulator die phasenweise Abarbeitung eines Mikrobefehls, der in eine sogenannte Hol-, Rechen- und Bring-Phase unterteilt ist. Die Abarbeitung der Teilphasen ist mit einer einstellbaren Verzögerung zur besseren Nachverfolgung möglich.
* Darauf aufbauend ist die komplette Abarbeitung eines Mikrobefehls in einem Dreiphasen-Takt ohne Verzögerung möglich. Ebenso die Abarbeitung mehrerer zu einem Maschinenbefehl zusammenfassbarer Mikrobefehle mittels eines in Mikrocode programmierten Maschinencodeinterpreters. Der Interpreter hat die Aufgabe, Maschinensprachebefehle, als Operationscodes in einem Byte-Wert codiert, aus dem RAM zu holen und an die entsprechende Mikrocodeunterprogrammadresse zur mikroprogrammierten Ausführung zu verzweigen.
* Darüber hinaus ist die Abarbeitung mehrerer Maschinenbefehle bis zu einem frei definierbaren Haltepunkt möglich. Dabei kann die Zeit bis zum Erreichen des Halte-Punkts für Simulationsoptimierungen gestoppt werden.
* Im höchsten Simulationsniveau kann der Mikrocodesimulator im Freilauf-Modus ohne jegliche Unterbrechung Maschinensprachesequenzen abarbeiten und somit die Interaktion der Applikation mit Ein- und Ausgabeschnittstellen in den Vordergrund rücken.

Mit verschiedenen Zusatzoptionen können visuelle CPU-Aktivitäten zu Gunsten der Steigerung der Abarbeitungsgeschwindigkeit unterdrückt werden, so dass die Maschinenprogrammierung der virtuellen Applikation in den Vordergrund tritt.
Mit dem Performance-Index-Monitor bietet der Simulator die Möglichkeit, die Abarbeitungsgeschwindigkeit und Ausführungsdauer entworfener Mikrobefehl-Sequenzen zu bestimmen und diese in Bezug zur Rechenleistung, gemessen in Gleitkommaoperationen pro Sekunde (FLOPS, engl. {{lang|en|[[Floating Point Operations Per Second]]}}) und [[Instruktionen pro Sekunde|Maschinen-/Mikrobefehle pro Sekunde]] (MIPs, engl. {{lang|en|Million Instructions per Second}}), der verwendeten Simulationshardware zu setzen.

Mit dem Zusatzprogramm MikroBAT, dem sogenannten „Basic Assembler Tool“ für MikroSim, können einfache Programme in [[Assembler (Informatik)|Assembler]] erstellt werden. Dabei wird der Befehlsumfang unterstützter [[Mnemonic]]s durch den Satz eigener mikrocodeprogrammierter Maschinenbefehle (Opcode) bestimmt. Das Zusatzprogramm ist in der Lage, das Assembler-Programm in Maschinencodes zu übersetzen und in den externen Datenspeicher für anschließende Simulationen zu übertragen.
Zusammen mit MikroBAT behandelt der Mikrocodesimulator in didaktisch aufbauender Weise Lehraspekte der technischen Informatik vom schaltergesteuerten Rechenautomaten bis zur Assembler programmierbaren Applikation.

== Literatur ==
* H.P.Gumm, M.Sommer: ''Einführung in die Informatik'', 8. Auflage. Oldenbourg, München 2009, ISBN 978-3-486-58724-1, (Zu MikroSim insbesondere Kap. 5.6, S.470-485.)

== Weblinks ==
* [http://www.mikrocodesimulator.de Mikrocodesimulator MikroSim] – Offizielle Website

== Einzelnachweise ==
<references />

[[Kategorie:Virtualisierung]]
[[Kategorie:Lernsoftware]]
[[Kategorie:Rechnerarchitektur]]
[[Kategorie:Assembler]]
[[Kategorie:Technische Informatik]]

[[en:MikroSim]]

Diskussion:MikroSim

2012-07-01T20:08:40Z

SimDoc: Überarbeitung

== Überarbeiten & Neutralität ==

Der ganze Artikel liest sich wie reine '''Werbung''', es gab zwar schon einen [[Wikipedia:L%C3%B6schkandidaten/24._Oktober_2010#MikroSim_.28bleibt.29 |Löschantrag]], aber eine Werbeplattform ist Wikipedia trotzdem nicht. Der Artikel sollte daher von der Werbung durch entsprechende Umformulierung befreit werden. --[[Spezial:Beiträge/84.58.231.117|84.58.231.117]] 17:15, 15. Jun. 2012 (CEST)
:Der Artikel ist recht ausführlich und klingt sicher nicht wie ein prägnanter Lexikoneintrag, da gebe ich dir Recht. Er ist allerdings neutral und objektiv verfasst und ist ''keinesfalls'' als ''reine Werbung'' anzusehen. Und ja: Werbung hat hier nix verloren, sondern nur Artikel mit belegbarer Relevanz, weswegen ja der Löschantrag zurückgenommen wurde. Hast du schon eine konkrete Idee, an welchen Textstellen durch Umformulierung der Artikel wie verbessert werden könnte? --[[Spezial:Beiträge/93.104.77.100|93.104.77.100]] 19:18, 17. Jun. 2012 (CEST)

Vielen Dank für Eure konstruktive Kritik. Ich habe den Artikel nun um eine InfoBox ergänzt und den Text überarbeitet. Gerne dürft Ihr Euch bei der Umformulierung weiterer Textpassagen beteiligen, wenn Euch etwas nicht gefällt.--[[Benutzer:SimDoc|SimDoc]] ([[Benutzer Diskussion:SimDoc|Diskussion]]) 22:08, 1. Jul. 2012 (CEST)

MikroSim

2012-07-01T19:53:29Z

SimDoc: Überarbeitung und Einfügen der Infobox

{{Infobox Software
| AktuelleVersion = 3.0.13
| AktuelleVersionFreigabeDatum = 20.6.2012
| Entwickler = Dr. Martin Perner
| Hersteller = 0/1-SimWare
| Betriebssystem = [[Microsoft Windows|Windows]]
| Programmiersprache = Visual Basic
| Lizenz = FreeWare/ShareWare
| Deutsch = ja
| Website = [http://www.mikrocodesimulator.de www.mikrocodesimlator.de]
}}

Das Programm '''MikroSim''' ist eine [[Lernsoftware]] für das [[Betriebssystem]] [[Microsoft Windows]] zur hardware-unspezifischen Erläuterung der allgemeinen Funktionsweise und Steuerabläufe einer virtuellen Rechenmaschine. Es lassen sich in allgemein verständlicher Weise miniaturisierte [[Rechenwerk]]e didaktisch auf [[Registertransferebene]] erläutern, die in [[Mikrocontroller]]n, [[Prozessor (Hardware)|Prozessoren]], und [[Computer]]n ablaufen.

== Allgemeines ==
Anfänglich wurde MikroSim als Prozessor-Simulationssoftware konzipiert. Da MikroSim allerdings die Programmierbarkeit ([[Mikroprogrammierung]]) eines [[Mikroprogrammsteuerwerk]]s mittels [[Mikrobefehl]]en in den Vordergrund stellt, betont die Anwendung als [[Mikrocodesimulator]] den Aspekt der Mikrocodesimulation. In der gegenwärtigen Entwicklung erlangt der [[Simulator]] den Status einer virtuellen Applikation. Dabei werden allgemeine Prinzipien der System- und [[Rechnerarchitektur]] aufgegriffen, die sich mit dem Beginn des [[Informationszeitalter]]s etabliert haben und noch heute bestand haben, ohne sich auf spezielle Hardwareaspekte zu beschränken. Auf diese Weise erlangt das Simulationswerkzeug einen zeitlosen, freien didaktischen Nutzen, ohne sich auf spezielle vergangene und zukünftige Entwicklungen festzulegen. Die detaillierte Dokumentation und die zweisprachige Benutzerführung der [[E-Learning]]-Anwendung in Deutsch und Englisch, sowie die Auslegung der Software für die weithin verbreiteten Windows-Betriebssysteme, ist der Grund für den nachhaltigen Bestand der Software im Lehrbetrieb auf dem Gebiet der [[technische Informatik|technischen Informatik]] in Ausbildung und Lehre seit 1992.

== Entwicklungsgeschichte ==
Die Software basiert auf einer freien, unter [[Turbo-Pascal]] für das Betriebssystem [[MS-DOS]] geschriebenen Programmversion, die bis 1992 an der [[Philipps-Universität Marburg]] in der Vorlesung zur technischen Informatik für die Erläuterung von Mikrocodesteuerprozessen herangezogen wurde. Das bis dahin etablierte didaktische Vorlesungskonzept wurde im Sommer 1992 von Martin Perner während seines Physik-[[Diplom]]studiums (1990–1995) aufgegriffen und in freier Arbeit auf das Betriebssystem [[Microsoft Windows 3.x|Windows 3.1]] unter [[Visual Basic]] 1.0 portiert. Dabei entstand der Simulator in einer für damalige Verhältnisse völlig neuartigen Konzeption mit weitreichender Funktionalitätsverbesserung. Die Weiterentwicklung der Lehrsoftware unter Windows wurde bis 1995 von dem Fachbereich Mathematik/Informatik der Universität Marburg durch Heinz-Peter Gumm gefördert. Der Simulator wurde im November 1994 mit dem ''Europäischen Hochschul-Software-Preis 1994'' in der Kategorie [[Informatik]] in [[Heidelberg]] ausgezeichnet und im März 1995 auf der Computermesse [[CeBit]] in Hannover am Stand der hessischen Hochschulen der Öffentlichkeit vorgestellt.

Im Zeitraum Ende 1995 bis Anfang 2000 wurde der Simulator mit wenigen Verbesserungen unter der Revision MikroSim 1.2 veröffentlicht. In diesem Zeitraum wurde MikroSim im Rahmen des ''Europäischen Jahres des lebensbegleitenden Lernens 1996'' mit 1000 ECU prämiert, sowie beim Wettbewerb ''Multimedia Transfer'97'' im Rahmen der Messe ''LearnTec’97'' vorgestellt.<ref>[http://www.mikrocodesimulator.de/index.php#PreiseAuszeichnungen Preise und Auszeichnungen] auf der MikroSim-Website (Abgerufen am 5. November 2010.)</ref> In seiner vorletzten Neuauflage wurde der Simulator unter dem Namen „Mikrocodesimulator MikroSim2000“ mittels der Programmiersprache MS-Visual Basic 4.0 für [[Microsoft Windows 95|Windows 95]] angepasst.

Im Zeitraum Anfang 2008 bis 2009 erfuhr der Simulator weitreichende konzeptionelle Erweiterungen, ohne die Möglichkeiten der Mikrocodesimulation im Kern zu verändern. Dabei wird die Rechenleistung heutiger Windows-Applikationen und der verwendeten Hardware ausgenutzt, um Simulationen bis hin zur virtuellen Applikation zu ermöglichen.
MikroSim ist als 32-Bit-Version kompiliert und für [[Microsoft Windows XP|Windows XP]] optimiert worden. Das Programm ist auf allen 32- und 64-Bit-Betriebssystem der Versionen [[Microsoft Windows Vista| Windows Vista]] und [[Microsoft Windows 7|Windows 7]] ohne spezielle XP-Kompatibilitätsmodi ausgeführbar. Seit Januar 2010 wird der Simulator unter „Mikrocodesimulator MikroSim 2010“ von 0/1-SimWare vertrieben.

== Funktionsweise und -umfang ==
Das Programm ermöglicht den schrittweisen Aufbau einer virtuellen Applikation, die in ihrer Funktionalität unveränderbar vorgegeben ist. Im Erkundungsmodus kann die Funktionsweise und Steuerungsmöglichkeit neu hinzugefügter Komponenten innerhalb eines Mikrocode-Befehlszyklus in Erfahrung gebracht werden. Die Breite der von MikroSim unterstützten Mikrobefehle umfasst 49 Bit. Ein Mikrobefehl wird in drei Teilphasen eines 3-Phasentakts abgearbeitet. Die Teilphasen werden als Hol-, Rechen- und Bringphase bezeichnet und bewirken das Holen eines 32 Bit breiten Registerwerts, das Ausführen einer 32-Bit-Berechnung, und das abschließende Speichern des Rechenergebnisses in einem CPU-internen [[Register (Computer)|Register]].

Im Simulationsmodus können hintereinander ausgeführte Mikrobefehle die zentrale Recheneinheit des Simulators steuern, wobei jeder Mikrobefehl auf die Adresse des nächsten Mikrobefehls verweist. Der Mikrobefehlssatz, gemeinhin als „Mikrocode“ der Recheneinheit bezeichnet, umfasst in der gegenwärtigen Implementierung von MikroSim 1024 49-Bit-lange Mikrobefehle. Strukturierungsmöglichkeiten im adressierbaren Ablaufplan im Mikrocode und die Entwicklung eines zyklisch arbeitenden, mikrocodeprogrammierten [[Interpreter]]s für Operationscodes (kurz [[Opcode]]s) ermöglichen die Implementierung von einzelnen mikrocodeprogrammierten Mikrobefehlssequenzen. Diese können als mikroprogrammierte [[Maschinenbefehl]]e aufgefasst werden. Der Mikrocode kann als [[Firmware]] für MikroSim als Mikrocode-[[Read-Only Memory|ROM]]-Datei (ROM, engl. {{lang|en|Read-Only Memory}}) abgelegt, modifiziert und erneut geladen werden.

Innerhalb eines Mikrobefehlzyklus kann sowohl die CPU als auch ein Ein-Ausgabe-Kontroller auf einen externen 16 kB umfassenden [[Random-Access Memory|RAM]]-[[Datenspeicher]] (RAM, engl. {{lang|en|Random-Access Memory}}) zurückgreifen. Über den Ein-Ausgabe-Kontroller erfolgt die Kommunikation mit angeschlossenen Ein- und Ausgabekomponenten mit [[Direct Memory Access|DMA]]-, [[I2C|I2C]]- und [[Interrupt Request|IRQ]]-Funktionalität. Unterstützt werden ein Ausgabe-Port, eine Anzeige, ein Zeitgeber, ein Ereignis-Trigger, ein Digital-Analog-Wandler, eine Tastatur und Daten-Ein-Ausgabe-Kanäle.

Der Mikrocodesimulator verwendet acht frei verwendbare 32-Bit-Register, deren Inhalt für vorzeichenbehaftete und vorzeichenlose Ganzzahlberechnungen, sowie für 32-Bit-Gleitkommaarithmetik eingesetzt werden. Mit einem übersichtlichen Systemzahleditor können die Registerinhalte betrachtet und modifiziert werden.

Die zentrale Recheneinheit des Simulators, die 32-Bit-[[Arithmetisch-logische Einheit|ALU]], unterstützt 128 verschiedene, grundlegende Rechenoperationen für Ganzzahlen und Interrupt-Steuerung bis hin zur [[Gleitkommaarithmetik]], die als erstes in vergleichbarer Weise bereits von [[Konrad Zuse]] eingeführt wurde. Zur Verdeutlichung dieser Arithmetik stehen elementare Rechenoperationen für die schrittweise auflösbare Gleitkomma-Registeroperationen in Mantisse und Exponent von den Grundberechnungen Addition/Subtraktion und Multiplikation/Division zur Verfügung. Weiterführend werden darauf aufbauend mächtigere 32-Bit-Rechenbefehle der Gleitkommaarithmetik in Mantisse und Exponent für die Grundrechenarten und elementarer analytischer Funktionen bereitgestellt, wie sie in mathematischen [[Coprozessor]]en realisiert sind. Dabei wird idealisiert angenommen, dass jede der 128 unterstützten ALU-Rechenoperationen für die Ausführung nur einen virtuellen Rechentakt benötigt.

Die Mikrobefehle können auf verschiedenen Simulationsniveaus ausgeführt werden:
* In dem niedrigsten Simulationsniveau unterstützt der Simulator die phasenweise Abarbeitung eines Mikrobefehls, der in eine sogenannte Hol-, Rechen- und Bring-Phase unterteilt ist. Die Abarbeitung der Teilphasen ist mit einer einstellbaren Verzögerung zur besseren Nachverfolgung möglich.
* Darauf aufbauend ist die komplette Abarbeitung eines Mikrobefehls in einem Dreiphasen-Takt ohne Verzögerung möglich. Ebenso die Abarbeitung mehrerer zu einem Maschinenbefehl zusammenfassbarer Mikrobefehle mittels eines in Mikrocode programmierten Maschinencodeinterpreters. Der Interpreter hat die Aufgabe, Maschinensprachebefehle, als Operationscodes in einem Byte-Wert codiert, aus dem RAM zu holen und an die entsprechende Mikrocodeunterprogrammadresse zur mikroprogrammierten Ausführung zu verzweigen.
* Darüber hinaus ist die Abarbeitung mehrerer Maschinenbefehle bis zu einem frei definierbaren Haltepunkt möglich. Dabei kann die Zeit bis zum Erreichen des Halte-Punkts für Simulationsoptimierungen gestoppt werden.
* Im höchsten Simulationsniveau kann der Mikrocodesimulator im Freilauf-Modus ohne jegliche Unterbrechung Maschinensprachesequenzen abarbeiten und somit die Interaktion der Applikation mit Ein- und Ausgabeschnittstellen in den Vordergrund rücken.

Mit verschiedenen Zusatzoptionen können visuelle CPU-Aktivitäten zu Gunsten der Steigerung der Abarbeitungsgeschwindigkeit unterdrückt werden, so dass die Maschinenprogrammierung der virtuellen Applikation in den Vordergrund tritt.
Mit dem Performance-Index-Monitor bietet der Simulator die Möglichkeit, die Abarbeitungsgeschwindigkeit und Ausführungsdauer entworfener Mikrobefehl-Sequenzen zu bestimmen und diese in Bezug zur Rechenleistung, gemessen in Gleitkommaoperationen pro Sekunde (FLOPS, engl. {{lang|en|[[Floating Point Operations Per Second]]}}) und [[Instruktionen pro Sekunde|Maschinen-/Mikrobefehle pro Sekunde]] (MIPs, engl. {{lang|en|Million Instructions per Second}}), der verwendeten Simulationshardware zu setzen.

Mit dem Zusatzprogramm MikroBAT, dem sogenannten „Basic Assembler Tool“ für MikroSim, können einfache Programme in [[Assembler (Informatik)|Assembler]] erstellt werden. Dabei wird der Befehlsumfang unterstützter [[Mnemonic]]s durch den Satz eigener mikrocodeprogrammierter Maschinenbefehle (Opcode) bestimmt. Das Zusatzprogramm ist in der Lage, das Assembler-Programm in Maschinencodes zu übersetzen und in den externen Datenspeicher für anschließende Simulationen zu übertragen.
Zusammen mit MikroBAT behandelt der Mikrocodesimulator in didaktisch aufbauender Weise Lehraspekte der technischen Informatik vom schaltergesteuerten Rechenautomaten bis zur Assembler programmierbaren Applikation.

== Literatur ==
* H.P.Gumm, M.Sommer: ''Einführung in die Informatik'', 8. Auflage. Oldenbourg, München 2009, ISBN 978-3-486-58724-1, (Zu MikroSim insbesondere Kap. 5.6, S.470-485.)

== Weblinks ==
* [http://www.mikrocodesimulator.de Mikrocodesimulator MikroSim] – Offizielle Website

== Einzelnachweise ==
<references />

[[Kategorie:Virtualisierung]]
[[Kategorie:Lernsoftware]]
[[Kategorie:Rechnerarchitektur]]
[[Kategorie:Assembler]]
[[Kategorie:Technische Informatik]]

[[en:MikroSim]]

Diskussion:Mikrocode

2011-07-26T19:43:39Z

SimDoc: /* Microcode */ Bedeutende Relevanz

Mikroprogrammsteuerwerk

2011-05-13T09:06:56Z

SimDoc: Umformulierung mit Verweis auf Steuerwerk

Ein '''Mikroprogrammsteuerwerk''' ist der Teil ''mikroprogrammierter'' [[Hauptprozessor|Prozessoren]], der die Ausführung eines [[Maschinencode|Befehls]] im Prozessor steuert. Das [[Steuerwerk]] hat Zugriff auf [[Mikroprogramm]]en, die in einem Speicher abgelegt sind. Die Mikroprogramme steuern das Zusammenspiel von Prozessoreinheiten wie zum Beispiel der [[Arithmetisch-logische Einheit|ALU]] oder den [[Register (Computer)|Registern]]. Bei manchen Prozessoren können die Mikroprogramme auch nachträglich mittels [[Mikrocodeprogrammierung]] geändert werden. Man kann Mikroprogramme auch als [[Firmware]] der CPU auffassen.

== Funktionsweise ==
[[Maschinencode]]s müssen in einem Prozessor mittels sogenannter [[Mikrobefehl]]e in Steuersignale für die einzelnen Funktionseinheiten umgesetzt werden. Unter Umständen müssen dazu mehrere aufeinander folgende Verarbeitungsschritte ausgelöst werden, um die Funktion des Maschinencodes in Form einer Mikrobefehlssequenz zu realisieren.

Nehmen wir als Beispiel den Befehl ''ADD A,B'' eines fiktiven Prozessors, der die Inhalte der Register A und B addieren und das Ergebnis in das Register A zurückschreiben soll. Es könnte folgender Steuerablauf im Prozessor ablaufen: 

# Die [[Arithmetisch-logische Einheit|ALU]] wird für eine Addition konfiguriert.
# Der Inhalt von Register A wird an den ersten Eingang der ALU angelegt.
# Der Inhalt von Register B wird an den zweiten Eingang der ALU angelegt.
# Nach dem Ablauf der Durchlaufzeit für das Auslesen der Register A und B, sowie die Ausführung der Addition in der ALU wird das Ergebnis in ein Zwischenregister abgelegt.
# Der Inhalt von Register A wird mit dem Wert aus dem Zwischenregister überschrieben.
# Der nächste Befehl wird aus dem Speicher gelesen.
Denkbar wäre, die Schritte 1, 2, 3 und 5, 6 in jeweils einem Zeitintervall zusammengefasst ablaufen zu lassen.

Um diesen Ablauf zu steuern ist es möglich, eine Logik aufzubauen, die direkt diese Steuerung vornimmt. Der Nachteil bei dieser „festen Verdrahtung“ der Befehle ist die Komplexität der notwendigen Logik und die geringe Flexibilität bei notwendigen Veränderungen.

Im Falle der [[Mikroprogrammierung]] wird eine solche Ablaufsteuerung über die in einem Speicher abgelegten [[Mikroprogramm]]e realisiert. Der Maschinencode aktiviert dabei jeweils eines der Mikroprogramme, das in mehreren Schritten dann jeweils alle notwendigen Steuersignale für die Funktionseinheiten erzeugt. Im einfachsten Falle ist das Mikroprogrammsteuerwerk aufgebaut aus einem Befehlsregister, das den gerade ausgeführten Maschinencode enthält, einem Zähler für die Mikroprogrammschritte und einem Speicher, der die einzelnen Schritte enthält. Das Befehlsregister und der Zähler zusammen ergeben dann die Adresse für den Mikroprogrammspeicher. Es sind aber auch komplexere Mikroprogrammsteuerwerke möglich, die Sprungbefehle und Verzweigungen ausführen können, um komplexere Befehle zu ermöglichen. Die Bedeutung eines Mikroprogrammsteuerwerks als Leitwerk für die Steuerung eines virtuellen Rechenwerks wird mit dem Mikrocodesimulator [[MikroSim]] auf didaktische Weise vermittelt.

== Entwicklung ==
Frühe Prozessoren waren typischerweise mit fest verdrahteter Logik aufgebaut, später wurden dann vermehrt Mikroprogrammsteuerwerke eingesetzt. Diese Entwicklung hat sich bei den [[Mainframe|Mainframe-Computern]], wie auch später bei den [[Mikroprozessor]]en abgespielt. Mit der Entwicklung zu immer höheren Taktfrequenzen und zu [[Reduced Instruction Set Computer|RISC]]-Prozessoren ging dann allerdings der Trend wieder zu fest verdrahteter Logik. Aktuelle Prozessoren verwenden oft eine Mischform, bei der häufig verwendete Befehle oder Befehlsteile mit fest verdrahteter Logik ausgeführt werden und komplexe, oder nicht so zeitkritische Befehle ganz oder teilweise mit Mikrocode.

Einige Prozessoren können ihre Mikroprogrammierung auch selbst dynamisch ändern, zum Beispiel um einen anderen [[Befehlssatz]] zu erlauben oder die Ausführung zu [[Optimierung|optimieren]]. In einigen Fällen kann ein Teil des fest in einem Prozessor verankerten Mikrocodes durch nachgeladenen Mikrocode ersetzt werden um Fehler im Prozessor zu kompensieren.

Mikroprogrammsteuerwerke sind eine Form von [[Speicherprogrammierbare Steuerung|speicherprogrammierbarer Steuerung]]. Ihr Einsatz ist nicht auf Prozessoren begrenzt.

== Literatur ==
*R. Hoffmann: ''Rechnerentwurf: Rechenwerke, Mikroprogrammierung, RISC.'' 3. Auflage. Oldenbourg, München 1993, ISBN 978-3-486-22174-9 (insbesondere Kap. 5: Mikroprogrammierung).
*{{cite book | author= H.P. Gumm, M. Sommer | title=Einführung in die Informatik | publisher=Oldenbourg, 8. Auflage |year=2009 |isbn=978-3-486-58724-1}}
*{{cite book | author= K. Wüst| title=Mikroprozessortechnik: Grundlagen, Architekturen und Programmierung von Mikroprozessoren, Mikrocontrollern und Signalprozessoren | publisher=Vieweg+Teubner Verlag, 3. Auflage |year=2008 |isbn=978-3-834-80461-7}}
*{{cite book | author= H. Bähring| title=Mikrorechner-Technik, Band 1, Mikroprozessoren und Digitale Signalprozessoren | publisher=Springer, 3. Auflage |year=2002 |isbn=3-540-41648-x}}
*{{cite book | author= H. Bähring| title=Mikrorechner-Technik, Band 2, Busse, Speicher, Pheriperie und Mikrocontroller| publisher=Springer, 3. Auflage |year=2002 |isbn=3-540-43693-6}}
*{{cite book | author= Bringschulte, Ungerer| title=Mikrocontroller und Mikroprozessoren| publisher=Springer |year=2002 |isbn=3-540-43095-4}}
*{{cite book | author= R. Kelch| title=Rechnergrundlagen - Von der Binärlogik zum Schaltwerk| publisher=Fachbuchverlag Leipzig |year=2003 |isbn=3-446-22112-1}}
*{{cite book | author= R. Kelch| title=Rechnergrundlagen - Vom Rechenwerk zum Universalrechner| publisher=Fachbuchverlag Leipzig |year=2003 |isbn=3-446-22113-1}}
*{{cite book | author= Ch. Märtin| title=Einführung in die Rechnerarchitektur - Prozessoren und Systeme| publisher=Fachbuchverlag Leipzig |year=2003 |isbn=3-446-22242-1}}

== Weblinks ==
*{{cite web|url=http://www.mikrocodesimulator.de/ |title=Mikrocodesimulator MikroSim 2010 |publisher=0/1-SimWare |date= |accessdate=2010-10-03}}



[[Kategorie:Rechnerarchitektur]]
[[Kategorie:Firmware]]
[[Kategorie:Technische Informatik]]

Mikroprogrammsteuerwerk

2011-01-27T15:19:36Z

SimDoc: /* Weblinks */ Netter Filmbeitrag, enzyklopädisch aber zu speziell

Ein '''Mikroprogrammsteuerwerk''' ist der Teil ''mikroprogrammierter'' [[Hauptprozessor|Prozessoren]], der die Ausführung eines [[Maschinencode|Befehls]] im Prozessor steuert. Das Steuerwerk enthält eine Menge von Mikroprogrammen, die jeweils aus einer Liste von Steuersignalen bestehen, die das Verhalten von Prozessorelementen – zum Beispiel der [[Arithmetisch-logische Einheit|ALU]] und den [[Register (Computer)|Registern]] – regeln. Bei manchen Prozessoren können die Mikroprogramme auch nachträglich mittels [[Mikrocodeprogrammierung]] geändert werden. Man könnte die Mikroprogramme auch als [[Firmware]] der CPU bezeichnen.

== Funktionsweise ==
[[Maschinencode]]s müssen in einem Prozessor mittels sogenannter [[Mikrobefehl]]e in Steuersignale für die einzelnen Funktionseinheiten umgesetzt werden. Unter Umständen müssen dazu mehrere aufeinander folgende Verarbeitungsschritte ausgelöst werden, um die Funktion des Maschinencodes in Form einer Mikrobefehlssequenz zu realisieren.

Nehmen wir als Beispiel den Befehl ''ADD A,B'' eines fiktiven Prozessors, der die Inhalte der Register A und B addieren und das Ergebnis in das Register A zurückschreiben soll. Es könnte folgender Steuerablauf im Prozessor ablaufen: 

# Die [[Arithmetisch-logische Einheit|ALU]] wird für eine Addition konfiguriert.
# Der Inhalt von Register A wird an den ersten Eingang der ALU angelegt.
# Der Inhalt von Register B wird an den zweiten Eingang der ALU angelegt.
# Nach dem Ablauf der Durchlaufzeit für das Auslesen der Register A und B, sowie die Ausführung der Addition in der ALU wird das Ergebnis in ein Zwischenregister abgelegt.
# Der Inhalt von Register A wird mit dem Wert aus dem Zwischenregister überschrieben.
# Der nächste Befehl wird aus dem Speicher gelesen.
Denkbar wäre, die Schritte 1, 2, 3 und 5, 6 in jeweils einem Zeitintervall zusammengefasst ablaufen zu lassen.

Um diesen Ablauf zu steuern ist es möglich, eine Logik aufzubauen, die direkt diese Steuerung vornimmt. Der Nachteil bei dieser „festen Verdrahtung“ der Befehle ist die Komplexität der notwendigen Logik und die geringe Flexibilität bei notwendigen Veränderungen.

Im Falle der [[Mikroprogrammierung]] wird eine solche Ablaufsteuerung über die in einem Speicher abgelegten [[Mikroprogramm]]e realisiert. Der Maschinencode aktiviert dabei jeweils eines der Mikroprogramme, das in mehreren Schritten dann jeweils alle notwendigen Steuersignale für die Funktionseinheiten erzeugt. Im einfachsten Falle ist das Mikroprogrammsteuerwerk aufgebaut aus einem Befehlsregister, das den gerade ausgeführten Maschinencode enthält, einem Zähler für die Mikroprogrammschritte und einem Speicher, der die einzelnen Schritte enthält. Das Befehlsregister und der Zähler zusammen ergeben dann die Adresse für den Mikroprogrammspeicher. Es sind aber auch komplexere Mikroprogrammsteuerwerke möglich, die Sprungbefehle und Verzweigungen ausführen können, um komplexere Befehle zu ermöglichen. Die Bedeutung eines Mikroprogrammsteuerwerks als Leitwerk für die Steuerung eines virtuellen Rechenwerks wird mit dem Mikrocodesimulator [[MikroSim]] auf didaktische Weise vermittelt.

== Entwicklung ==
Frühe Prozessoren waren typischerweise mit fest verdrahteter Logik aufgebaut, später wurden dann vermehrt Mikroprogrammsteuerwerke eingesetzt. Diese Entwicklung hat sich bei den [[Mainframe|Mainframe-Computern]], wie auch später bei den [[Mikroprozessor]]en abgespielt. Mit der Entwicklung zu immer höheren Taktfrequenzen und zu [[Reduced Instruction Set Computer|RISC]]-Prozessoren ging dann allerdings der Trend wieder zu fest verdrahteter Logik. Aktuelle Prozessoren verwenden oft eine Mischform, bei der häufig verwendete Befehle oder Befehlsteile mit fest verdrahteter Logik ausgeführt werden und komplexe, oder nicht so zeitkritische Befehle ganz oder teilweise mit Mikrocode.

Einige Prozessoren können ihre Mikroprogrammierung auch selbst dynamisch ändern, zum Beispiel um einen anderen [[Befehlssatz]] zu erlauben oder die Ausführung zu [[Optimierung|optimieren]]. In einigen Fällen kann ein Teil des fest in einem Prozessor verankerten Mikrocodes durch nachgeladenen Mikrocode ersetzt werden um Fehler im Prozessor zu kompensieren.

Mikroprogrammsteuerwerke sind eine Form von [[Speicherprogrammierbare Steuerung|speicherprogrammierbarer Steuerung]]. Ihr Einsatz ist nicht auf Prozessoren begrenzt.

== Literatur ==
*R. Hoffmann: ''Rechnerentwurf: Rechenwerke, Mikroprogrammierung, RISC.'' 3. Auflage. Oldenbourg, München 1993, ISBN 978-3-486-22174-9 (insbesondere Kap. 5: Mikroprogrammierung).
*{{cite book | author= H.P. Gumm, M. Sommer | title=Einführung in die Informatik | publisher=Oldenbourg, 8. Auflage |year=2009 |isbn=978-3-486-58724-1}}
*{{cite book | author= K. Wüst| title=Mikroprozessortechnik: Grundlagen, Architekturen und Programmierung von Mikroprozessoren, Mikrocontrollern und Signalprozessoren | publisher=Vieweg+Teubner Verlag, 3. Auflage |year=2008 |isbn=978-3-834-80461-7}}
*{{cite book | author= H. Bähring| title=Mikrorechner-Technik, Band 1, Mikroprozessoren und Digitale Signalprozessoren | publisher=Springer, 3. Auflage |year=2002 |isbn=3-540-41648-x}}
*{{cite book | author= H. Bähring| title=Mikrorechner-Technik, Band 2, Busse, Speicher, Pheriperie und Mikrocontroller| publisher=Springer, 3. Auflage |year=2002 |isbn=3-540-43693-6}}
*{{cite book | author= Bringschulte, Ungerer| title=Mikrocontroller und Mikroprozessoren| publisher=Springer |year=2002 |isbn=3-540-43095-4}}
*{{cite book | author= R. Kelch| title=Rechnergrundlagen - Von der Binärlogik zum Schaltwerk| publisher=Fachbuchverlag Leipzig |year=2003 |isbn=3-446-22112-1}}
*{{cite book | author= R. Kelch| title=Rechnergrundlagen - Vom Rechenwerk zum Universalrechner| publisher=Fachbuchverlag Leipzig |year=2003 |isbn=3-446-22113-1}}
*{{cite book | author= Ch. Märtin| title=Einführung in die Rechnerarchitektur - Prozessoren und Systeme| publisher=Fachbuchverlag Leipzig |year=2003 |isbn=3-446-22242-1}}

== Weblinks ==
*{{cite web|url=http://www.mikrocodesimulator.de/ |title=Mikrocodesimulator MikroSim 2010 |publisher=0/1-SimWare |date= |accessdate=2010-10-03}}



[[Kategorie:Rechnerarchitektur]]
[[Kategorie:Firmware]]
[[Kategorie:Technische Informatik]]

[[en:Control unit]]

Mikroprogrammsteuerwerk

2011-01-27T15:16:52Z

SimDoc: /* Literatur */ Lesenswerte Literatur

Ein '''Mikroprogrammsteuerwerk''' ist der Teil ''mikroprogrammierter'' [[Hauptprozessor|Prozessoren]], der die Ausführung eines [[Maschinencode|Befehls]] im Prozessor steuert. Das Steuerwerk enthält eine Menge von Mikroprogrammen, die jeweils aus einer Liste von Steuersignalen bestehen, die das Verhalten von Prozessorelementen – zum Beispiel der [[Arithmetisch-logische Einheit|ALU]] und den [[Register (Computer)|Registern]] – regeln. Bei manchen Prozessoren können die Mikroprogramme auch nachträglich mittels [[Mikrocodeprogrammierung]] geändert werden. Man könnte die Mikroprogramme auch als [[Firmware]] der CPU bezeichnen.

== Funktionsweise ==
[[Maschinencode]]s müssen in einem Prozessor mittels sogenannter [[Mikrobefehl]]e in Steuersignale für die einzelnen Funktionseinheiten umgesetzt werden. Unter Umständen müssen dazu mehrere aufeinander folgende Verarbeitungsschritte ausgelöst werden, um die Funktion des Maschinencodes in Form einer Mikrobefehlssequenz zu realisieren.

Nehmen wir als Beispiel den Befehl ''ADD A,B'' eines fiktiven Prozessors, der die Inhalte der Register A und B addieren und das Ergebnis in das Register A zurückschreiben soll. Es könnte folgender Steuerablauf im Prozessor ablaufen: 

# Die [[Arithmetisch-logische Einheit|ALU]] wird für eine Addition konfiguriert.
# Der Inhalt von Register A wird an den ersten Eingang der ALU angelegt.
# Der Inhalt von Register B wird an den zweiten Eingang der ALU angelegt.
# Nach dem Ablauf der Durchlaufzeit für das Auslesen der Register A und B, sowie die Ausführung der Addition in der ALU wird das Ergebnis in ein Zwischenregister abgelegt.
# Der Inhalt von Register A wird mit dem Wert aus dem Zwischenregister überschrieben.
# Der nächste Befehl wird aus dem Speicher gelesen.
Denkbar wäre, die Schritte 1, 2, 3 und 5, 6 in jeweils einem Zeitintervall zusammengefasst ablaufen zu lassen.

Um diesen Ablauf zu steuern ist es möglich, eine Logik aufzubauen, die direkt diese Steuerung vornimmt. Der Nachteil bei dieser „festen Verdrahtung“ der Befehle ist die Komplexität der notwendigen Logik und die geringe Flexibilität bei notwendigen Veränderungen.

Im Falle der [[Mikroprogrammierung]] wird eine solche Ablaufsteuerung über die in einem Speicher abgelegten [[Mikroprogramm]]e realisiert. Der Maschinencode aktiviert dabei jeweils eines der Mikroprogramme, das in mehreren Schritten dann jeweils alle notwendigen Steuersignale für die Funktionseinheiten erzeugt. Im einfachsten Falle ist das Mikroprogrammsteuerwerk aufgebaut aus einem Befehlsregister, das den gerade ausgeführten Maschinencode enthält, einem Zähler für die Mikroprogrammschritte und einem Speicher, der die einzelnen Schritte enthält. Das Befehlsregister und der Zähler zusammen ergeben dann die Adresse für den Mikroprogrammspeicher. Es sind aber auch komplexere Mikroprogrammsteuerwerke möglich, die Sprungbefehle und Verzweigungen ausführen können, um komplexere Befehle zu ermöglichen. Die Bedeutung eines Mikroprogrammsteuerwerks als Leitwerk für die Steuerung eines virtuellen Rechenwerks wird mit dem Mikrocodesimulator [[MikroSim]] auf didaktische Weise vermittelt.

== Entwicklung ==
Frühe Prozessoren waren typischerweise mit fest verdrahteter Logik aufgebaut, später wurden dann vermehrt Mikroprogrammsteuerwerke eingesetzt. Diese Entwicklung hat sich bei den [[Mainframe|Mainframe-Computern]], wie auch später bei den [[Mikroprozessor]]en abgespielt. Mit der Entwicklung zu immer höheren Taktfrequenzen und zu [[Reduced Instruction Set Computer|RISC]]-Prozessoren ging dann allerdings der Trend wieder zu fest verdrahteter Logik. Aktuelle Prozessoren verwenden oft eine Mischform, bei der häufig verwendete Befehle oder Befehlsteile mit fest verdrahteter Logik ausgeführt werden und komplexe, oder nicht so zeitkritische Befehle ganz oder teilweise mit Mikrocode.

Einige Prozessoren können ihre Mikroprogrammierung auch selbst dynamisch ändern, zum Beispiel um einen anderen [[Befehlssatz]] zu erlauben oder die Ausführung zu [[Optimierung|optimieren]]. In einigen Fällen kann ein Teil des fest in einem Prozessor verankerten Mikrocodes durch nachgeladenen Mikrocode ersetzt werden um Fehler im Prozessor zu kompensieren.

Mikroprogrammsteuerwerke sind eine Form von [[Speicherprogrammierbare Steuerung|speicherprogrammierbarer Steuerung]]. Ihr Einsatz ist nicht auf Prozessoren begrenzt.

== Literatur ==
*R. Hoffmann: ''Rechnerentwurf: Rechenwerke, Mikroprogrammierung, RISC.'' 3. Auflage. Oldenbourg, München 1993, ISBN 978-3-486-22174-9 (insbesondere Kap. 5: Mikroprogrammierung).
*{{cite book | author= H.P. Gumm, M. Sommer | title=Einführung in die Informatik | publisher=Oldenbourg, 8. Auflage |year=2009 |isbn=978-3-486-58724-1}}
*{{cite book | author= K. Wüst| title=Mikroprozessortechnik: Grundlagen, Architekturen und Programmierung von Mikroprozessoren, Mikrocontrollern und Signalprozessoren | publisher=Vieweg+Teubner Verlag, 3. Auflage |year=2008 |isbn=978-3-834-80461-7}}
*{{cite book | author= H. Bähring| title=Mikrorechner-Technik, Band 1, Mikroprozessoren und Digitale Signalprozessoren | publisher=Springer, 3. Auflage |year=2002 |isbn=3-540-41648-x}}
*{{cite book | author= H. Bähring| title=Mikrorechner-Technik, Band 2, Busse, Speicher, Pheriperie und Mikrocontroller| publisher=Springer, 3. Auflage |year=2002 |isbn=3-540-43693-6}}
*{{cite book | author= Bringschulte, Ungerer| title=Mikrocontroller und Mikroprozessoren| publisher=Springer |year=2002 |isbn=3-540-43095-4}}
*{{cite book | author= R. Kelch| title=Rechnergrundlagen - Von der Binärlogik zum Schaltwerk| publisher=Fachbuchverlag Leipzig |year=2003 |isbn=3-446-22112-1}}
*{{cite book | author= R. Kelch| title=Rechnergrundlagen - Vom Rechenwerk zum Universalrechner| publisher=Fachbuchverlag Leipzig |year=2003 |isbn=3-446-22113-1}}
*{{cite book | author= Ch. Märtin| title=Einführung in die Rechnerarchitektur - Prozessoren und Systeme| publisher=Fachbuchverlag Leipzig |year=2003 |isbn=3-446-22242-1}}

== Weblinks ==
*{{cite web|url=http://www.mikrocodesimulator.de/ |title=Mikrocodesimulator MikroSim 2010 |publisher=0/1-SimWare |date= |accessdate=2010-10-03}}
*[http://daniel.netsniff-ng.org/microtowers/ Spiel Türme von Hanoi implementiert in einem Mikroprogrammsteuerwerk]



[[Kategorie:Rechnerarchitektur]]
[[Kategorie:Firmware]]
[[Kategorie:Technische Informatik]]

[[en:Control unit]]

Mikroprogramm

2011-01-19T14:29:51Z

SimDoc: Neue Links eingebunden

Das '''Mikroprogramm''' ist der Algorithmus eines [[Mikroprogrammsteuerwerk]]s in einem [[Prozessor]] zum Steuern seines [[Rechenwerk]]s. Mikroprogramme werden mittels [[Mikroprogrammierung]] erstellt. Dazu werden [[Mikrobefehl]]e eines Mikroprogramms in einer adressierbaren Reihenfolge angeordnet und in einem [[Festwertspeicher]], dem sog. [[Mikroprogrammspeicher]], bereitgestellt. Die Mikrobefehle enthalten in binärer Form codierte Anweisungen mit fester Bit-Anzahl zur Aktivierung und Deaktivierung logischer Funktionseinheiten. Auf diese Weise bestimmt das Mikroprogrammsteuerwerk mit Hilfe des Mikroprogramms, welche Schaltvorgänge in welcher Reihenfolge zur Umsetzung von Maschinenbefehlen für ein Rechenwerk benötigt werden. Unter Umständen werden Schaltvorgänge nicht in vollem Umfang unmittelbar durch den Mikrocode initiiert, sondern durch nachgeordnete [[Nanoprogramm]]e, die als [[Nanocode]] realisiert sind. Die Gesamtheit aller im Mikroprogrammspeicher binär codierten Mikrobefehle bilden den [[Mikrocode]].

Zusätzlich enthalten die [[Mikrobefehl]]e eine inhärent codierte Adressierungsvorschrift, mit deren Hilfe die Position des nächsten anzusteuernden Mikrobefehls zur taktweisen, zyklischen Abarbeitung des Steuerablaufplans berechnet werden kann. Auf diese Weise ist es möglich, Mikrobefehle im Mikroprogramm nicht nur in aufsteigender Adressreihenfolge mit einfacher Sprungweite auszuführen, sondern ebenso in Adressierungssequenzen, die absolute, relative und bedingte Adressierungssprünge beinhalten können. Somit besteht die Möglichkeit einer möglichst redundanzfreien Strukturierung des Ablaufplans bzgl. sich wiederholender Mikrobefehlssequenzen. Somit besteht die Möglichkeit den begrenzt vorhandenen Mikrobefehlsspeicher in einer CPU für die Programmierung von Maschinenbefehlen in der Steuersprache der Mikrobefehle möglichst effektiv zu nutzen.

Das Mikroprogramm kann unmittelbar in Form binär codierter Mikrobefehle erstellt werden. Aber auch Hilfsmittel wie Mikroassembler können zur Mikroprogrammierung herangezogen werden, um die Steueranweisungen der Mikrobefehle eines Mikrocodeprogramms aus einer lesbaren Darstellung in die unübersichtliche binäre Mikrobefehlsform automatisiert zu übersetzen. Gleichzeitig kann mit dem [[Mikroassembler]] der Mikroprogrammspeicherinhalt und die inhärent codierte Adressierungsreihenfolge einer programmierten Mikrobefehlssequenz flexibel verwaltet werden. Die Erstellung eines Mikroprogramms zur Steuerung einer virtuellen Recheneinheit wird mit dem [[Mikrocodesimulator]] [[MikroSim]] auf didaktische Weise vermittelt.

== Literatur ==
*{{cite book | author= H.P. Gumm, M. Sommer | title=Einführung in die Informatik | publisher=Oldenbourg, 8. Auflage |year=2009 |isbn=978-3-486-58724-1}}
*{{cite book | author= K. Wüst| title=Mikroprozessortechnik: Grundlagen, Architekturen und Programmierung von Mikroprozessoren, Mikrocontrollern und Signalprozessoren | publisher=Vieweg+Teubner Verlag, 3. Auflage |year=2008 |isbn=978-3-834-80461-7}}
*{{cite book | author= H. Bähring| title=Mikrorechner-Technik, Band 1, Mikroprozessoren und Digitale Signalprozessoren | publisher=Springer, 3. Auflage |year=2002 |isbn=3-540-41648-x}}
*{{cite book | author= H. Bähring| title=Mikrorechner-Technik, Band 2, Busse, Speicher, Peripherie und Mikrocontroller| publisher=Springer, 3. Auflage |year=2002 |isbn=3-540-43693-6}}
*{{cite book | author= Bringschulte, Ungerer| title=Mikrocontroller und Mikroprozessoren| publisher=Springer |year=2002 |isbn=3-540-43095-4}}

== Weblinks ==
*{{cite web|url=http://www.mikrocodesimulator.de/ |title=Mikrocodesimulator MikroSim 2010 |publisher=0/1-SimWare |date= |accessdate=2010-10-03}}
*{{cite web|url=http://www.stéen.se/share/unix/kernel/microcode/microcode.pdf
|title=P6 Family Processor Microcode Update, Feature Review |publisher=J. Molina, W. Arbaugh |year=2000 |accessdate=2010-10-03}}
*{{cite web|url=http://www.cs.clemson.edu/~mark/uprog.html
|title=A Brief History of Microprogramming|publisher=M. Smotherman |year=2010 |accessdate=2010-10-03}}
*{{cite web|url=http://research.microsoft.com/en-us/um/people/gbell/Computer_Structures_Principles_and_Examples/csp0167.htm
|title=Computer Structures: Principles and Examples, Part 2, REGIONS OF COMPUTER SPACE, Section 1, MICROPROGRAM-BASED PROCESSORS, Seite 151 ff. |publisher=McGraw-Hill Computer Science Series |accessdate=2010-10-03}}
*{{cite web|url=http://www.intel.com/Assets/PDF/manual/253668.pdf |title=Intel(R) 64 and IA-32 Architectures Software Developer’s Manual, Volume 3A: System Programming Guide, Part 1, Chapter 9.11: "Microcode update facilities"|publisher=Intel Cooperation |date=December 2009 |accessdate=2010-10-03}}
*{{cite web|url=http://urbanmyth.org/microcode/ |title=Intel Microcode Update Utility for Linux|accessdate=2010-10-03}}
*{{cite web|url=http://support.microsoft.com/kb/936357 |title=A microcode reliability update is available that improves the reliability of systems that use Intel processors|Microsoft|accessdate=2010-10-03}}
*{{cite web|url=http://www.intel.com/support/motherboards/server/sb/cs-021619.htm| title=BIOS Update required when Missing Microcode message is seen during POST |publisher=Intel Cooperation |accessdate=2010-10-03}}

[[Kategorie:Systemsoftware]]
[[Kategorie:Rechnerarchitektur]]
[[Kategorie:Firmware]]
[[Kategorie:Technische Informatik]]

[[bs:Mikroprogram]]
[[en:Microprogram]]
[[fr:Microprogrammation]]
[[hr:Mikroprogramiranje]]
[[it:Microprogrammazione]]
[[pl:Mikroprogram]]
[[sh:Mikroprogramiranje]]
[[sr:Микропрограм]]
[[sv:Mikroprogram]]
[[tr:Mikroprogramlama]]

Mikroprogrammierung

2011-01-19T14:01:35Z

SimDoc: Links

Als '''Mikroprogrammierung''' wird die Methode und das Vorgehen verstanden Schalt-, Rechen- und Steuerabläufe in einem [[Rechenwerk]], insbesondere einem integrierten Rechenwerk ([[Mikrocontroller]], [[Mikroprozessor]]) unterhalb der Ausführungsebene von [[Maschinenbefehl]]en auf Mikrobefehlsebene festzulegen und zu regeln. Als Mikroprogrammierung kann die Erstellung eines Mikrobefehlssatzes als Abfolge von Mikrobefehlsequenzen in einer Art Steuersprache für Schalter verstanden werden. Vereinzelt wird durch den Begriff ''Mikrocode-Programmierung oder Mikrocodeprogrammierung'' die Erstellung des sogenannten [[Mikrocode]]s bei der Mikroprogrammierung betont, der die Binärform des Mikrobefehlssatzes darstellt.

Mit der Mikrocodeprogrammierbarkeit eines Rechenwerks ist das Vorhandensein eines dazu angepassten [[Mikroprogrammsteuerwerk]]s verbunden, welches durch die taktweise Abfolge der Mikrocodebefehlssequenz gesteuert wird. Die Möglichkeit einer flexibel programmierbaren Abfolgesteuerung von Mikrobefehlen setzt voraus, dass in jedem [[Mikrobefehl]] (engl. ''Micro Instruction'') selbst eine Berechnungsvorschrift zum Verweis, d. h. [[Adressierung (Datenverarbeitung)|Adressierung]], auf den nächsten anzusteuernden Mikrobefehl enthalten ist.

Üblicherweise ist ein Maschinensprachebefehlssatz eines [[Prozessor (Hardware)|Prozessors]] bei der Fertigung (z. B aus Kompatibilitätsgründen) vorgegeben und nicht veränderbar. Der den Maschinencode bildende Mikrobefehlssatz (kurz Mikrocode) ist in einem [[Festwertspeicher]] wie [[EPROM]] oder [[ROM]] inner- oder außerhalb des Rechenwerks untergebracht und wird ggf. bei der [[Initialisierung]] des Rechenwerks in das Mikroprogrammsteuerwerk geladen. Zur Optimierung von Schaltungsabläufen werden dennoch Möglichkeiten vorgesehen und Vorkehrungen getroffen, dass ein Mikrocode korrigiert, verbessert oder angepasst werden kann, um kostspielige Neuentwürfe im Sinne eines Mikrocode-[[Bugfix]] zu umgehen. In den Anfängen der Mikroprozessor-Ära war die Möglichkeit einer flexiblen Mikrocodeprogrammierung unumgänglich und gewünscht, um einzelne zu einem Baustein-Neuentwurf führende Implementierungsfehler zu verhindern. Mit den Fortschritten in der [[Verifikation]] und Integrierbarkeit digitaler Schaltungen schien der Aspekt der Umprogrammierbarkeit einige Zeit lang an Bedeutung zu verlieren.

Dennoch hat das Interesse an der Umprogrammierbarkeit im Laufe der letzten Jahre eine Wiederbelebung erfahren. So sind Mikroprozessoren der Firma Intel ab dem Modell Pentium Pro (P6) im Mikrocode umprogrammierbar. Der als [[FDIV-Bug]] bekannt gewordene Rechenfehler auf einem Teil der Intel Pentium-P5-Prozessoren konnte hingegen nicht durch Mikrocodeprogrammierung behoben werden sondern nur durch Prozessoraustausch. Mit der Mikrocodeprogrammierung ist die Möglichkeit gegeben, Rechensteuerwerke mittels Mikrocode-[[Update]]s für spezielle Betriebssysteme zu optimieren.

Das Vorgehen bei der Programmierung im Sinne der Zusammenstellung der Mikrobefehle zu einem Mikroprogramm wird im englischsprachigen Raum als ''Microcoding'' bezeichnet. Dabei werden Programmierwerkzeuge verwendet, die als [[Mikroassembler]] (engl. ''Microassembler'') bezeichnet werden. Mit diesen Hilfsmitteln ist es möglich, auf übersichtliche Weise Mikrobefehlssequenzen zu verwalten und diese in Binärcode zu übersetzen. Die Lernsoftware [[Mikrocodesimulator]] [[MikroSim]] vermittelt auf didaktische Weise die Bedeutung und das praktische Vorgehen bei der Mikroprogrammierung einer virtuellen Recheneinheit.

== Literatur ==
*{{cite book | author= H.P. Gumm, M. Sommer | title=Einführung in die Informatik | publisher=Oldenbourg, 8. Auflage |year=2009 |isbn=978-3-486-58724-1}}
*{{cite book | author= K. Wüst| title=Mikroprozessortechnik: Grundlagen, Architekturen und Programmierung von Mikroprozessoren, Mikrocontrollern und Signalprozessoren | publisher=Vieweg+Teubner Verlag, 3. Auflage |year=2008 |isbn=978-3-834-80461-7}}
*{{cite book | author= H. Bähring| title=Mikrorechner-Technik, Band 1, Mikroprozessoren und Digitale Signalprozessoren | publisher=Springer, 3. Auflage |year=2002 |isbn=3-540-41648-x}}
*{{cite book | author= H. Bähring| title=Mikrorechner-Technik, Band 2, Busse, Speicher, Peripherie und Mikrocontroller| publisher=Springer, 3. Auflage |year=2002 |isbn=3-540-43693-6}}
*{{cite book | author= Bringschulte, Ungerer| title=Mikrocontroller und Mikroprozessoren| publisher=Springer |year=2002 |isbn=3-540-43095-4}}

== Weblinks ==
*{{cite web|url=http://www.mikrocodesimulator.de/ |title=Mikrocodesimulator MikroSim 2010 |publisher=0/1-SimWare |date= |accessdate=2010-10-03}}
*{{cite web|url=http://www.stéen.se/share/unix/kernel/microcode/microcode.pdf
|title=P6 Family Processor Microcode Update, Feature Review |publisher=J. Molina, W. Arbaugh |year=2000 |accessdate=2010-10-03}}
*{{cite web|url=http://www.cs.clemson.edu/~mark/uprog.html
|title=A Brief History of Microprogramming|publisher=M. Smotherman |year=2010 |accessdate=2010-10-03}}
*{{cite web|url=http://research.microsoft.com/en-us/um/people/gbell/Computer_Structures_Principles_and_Examples/csp0167.htm
|title=Computer Structures: Principles and Examples, Part 2, REGIONS OF COMPUTER SPACE, Section 1, MICROPROGRAM-BASED PROCESSORS, Seite 151 ff. |publisher=McGraw-Hill Computer Science Series |accessdate=2010-10-03}}
*{{cite web|url=http://www.intel.com/Assets/PDF/manual/253668.pdf |title=Intel(R) 64 and IA-32 Architectures Software Developer’s Manual, Volume 3A: System Programming Guide, Part 1, Chapter 9.11: "Microcode update facilities"|publisher=Intel Cooperation |date=December 2009 |accessdate=2010-10-03}}
*{{cite web|url=http://urbanmyth.org/microcode/ |title=Intel Microcode Update Utility for Linux|accessdate=2010-10-03}}
*{{cite web|url=http://support.microsoft.com/kb/936357 |title=A microcode reliability update is available that improves the reliability of systems that use Intel processors|Microsoft|accessdate=2010-10-03}}
*{{cite web|url=http://www.intel.com/support/motherboards/server/sb/cs-021619.htm| title=BIOS Update required when Missing Microcode message is seen during POST |publisher=Intel Cooperation |accessdate=2010-10-03}}

[[Kategorie:Systemsoftware]]
[[Kategorie:Rechnerarchitektur]]
[[Kategorie:Firmware]]
[[Kategorie:Technische Informatik]]

[[en:Microprogramming]]
[[fr:Microprogrammation]]
[[hr:Mikroprogramiranje]]
[[it:Microprogrammazione]]
[[sh:Mikroprogramiranje]]

MikroSim

2011-01-11T10:16:47Z

SimDoc: /* Allgemeines */ Verweise ergänzt

Das Programm '''MikroSim''' ist eine [[Lernsoftware]] für das [[Betriebssystem]] [[Microsoft Windows]] zur hardware-unspezifischen Erläuterung der allgemeinen Funktionsweise und Steuerabläufe einer virtuellen Rechenmaschine. Es lassen sich in allgemein verständlicher Weise miniaturisierte [[Rechenwerk]]e didaktisch auf [[Registertransferebene]] erläutern, die in [[Mikrocontroller]]n, [[Prozessor (Hardware)|Prozessoren]], und [[Computer]]n ablaufen.

== Allgemeines ==
Anfänglich wurde MikroSim als Prozessor-Simulationssoftware konzipiert. Da MikroSim allerdings die Programmierbarkeit ([[Mikroprogrammierung]]) eines [[Mikroprogrammsteuerwerk]]s mittels [[Mikrobefehl]]en in den Vordergrund stellt, betont die Anwendung als [[Mikrocodesimulator]] den Aspekt der Mikrocodesimulation. In der gegenwärtigen Entwicklung erlangt der [[Simulator]] den Status einer virtuellen Applikation. Dabei werden allgemeine Prinzipien der System- und [[Rechnerarchitektur]] aufgegriffen, die sich mit dem Beginn des [[Informationszeitalter]]s etabliert haben und noch heute bestand haben, ohne sich auf spezielle Hardwareaspekte zu beschränken. Auf diese Weise erlangt das Simulationswerkzeug einen zeitlosen, freien didaktischen Nutzen, ohne sich auf spezielle vergangene und zukünftige Entwicklungen festzulegen. Die detaillierte Dokumentation und die zweisprachige Benutzerführung der [[E-Learning]]-Anwendung in Deutsch und Englisch, sowie die Auslegung der Software für die weithin verbreiteten Windows-Betriebssysteme, ist der Grund für den nachhaltigen Bestand der Software im Lehrbetrieb auf dem Gebiet der [[technische Informatik|technischen Informatik]] in Ausbildung und Lehre seit 1992.

== Entwicklungsgeschichte ==
Die Software basiert auf einer freien, unter [[Turbo-Pascal]] für das Betriebssystem [[MS-DOS]] geschriebenen Programmversion, die bis 1992 an der [[Philipps-Universität Marburg]] in der Vorlesung zur technischen Informatik für die Erläuterung von Mikrocodesteuerprozessen herangezogen wurde. Das bis dahin etablierte didaktische Vorlesungskonzept wurde im Sommer 1992 von Martin Perner während seines Physik-[[Diplom]]studiums (1990–1995) aufgegriffen und in freier Arbeit auf das Betriebssystem [[Microsoft Windows 3.x|Windows 3.1]] unter [[Visual Basic]] 1.0 portiert. Dabei entstand der Simulator in einer für damalige Verhältnisse völlig neuartigen Konzeption mit weitreichender Funktionalitätsverbesserung. Die Weiterentwicklung der Lehrsoftware unter Windows wurde bis 1995 von dem Fachbereich Mathematik/Informatik der Universität Marburg durch Heinz-Peter Gumm gefördert. Der Simulator wurde im November 1994 mit dem ''Europäischen Hochschul-Software-Preis 1994'' in der Kategorie [[Informatik]] in [[Heidelberg]] ausgezeichnet und im März 1995 auf der Computermesse [[CeBit]] in Hannover am Stand der hessischen Hochschulen der Öffentlichkeit vorgestellt.

Im Zeitraum Ende 1995 bis Anfang 2000 wurde der Simulator mit wenigen Verbesserungen unter der Revision MikroSim 1.2 veröffentlicht. In diesem Zeitraum wurde MikroSim im Rahmen des ''Europäischen Jahres des lebensbegleitenden Lernens 1996'' mit 1000 ECU prämiert, sowie beim Wettbewerb ''Multimedia Transfer'97'' im Rahmen der Messe ''LearnTec’97'' vorgestellt.<ref>[http://www.mikrocodesimulator.de/index.php#PreiseAuszeichnungen Preise und Auszeichnungen] auf der MikroSim-Website (Abgerufen am 5. November 2010.)</ref> In seiner vorletzten Neuauflage wurde der Simulator unter dem Namen „Mikrocodesimulator MikroSim2000“ mittels der Programmiersprache MS-Visual Basic 4.0 für [[Microsoft Windows 95|Windows 95]] angepasst.

Im Zeitraum Anfang 2008 bis 2009 erfuhr der Simulator weitreichende konzeptionelle Erweiterungen, ohne die Möglichkeiten der Mikrocodesimulation im Kern zu verändern. Dabei wird die Rechenleistung heutiger Windows-Applikationen und der verwendeten Hardware ausgenutzt, um Simulationen bis hin zur virtuellen Applikation zu ermöglichen. Seit Januar 2010 wird der Simulator unter „Mikrocodesimulator MikroSim 2010“ von 0/1-SimWare vertrieben.

== Kompatibilität ==
Die Software ist aus Kompatibilitätsgründen und zum Zweck einer möglichst weiten Verbreitung als 32-Bit-Version kompiliert und für [[Microsoft Windows XP|Windows XP]] optimiert worden. Das Programm kann auf allen 32- und 64-Bit-Betriebssystem der Versionen [[Microsoft Windows Vista| Windows Vista]] und [[Microsoft Windows 7|Windows 7]] ausgeführt werden. Auf spezielle XP-Kompatibilitätsmodi kann hierbei verzichtet werden.

== Lizenzierung und Bezug ==
Die MikroSim kann als frei verteilbare und kostenlose Demoversion mit Einschränkungen in der Funktionalität verwendet werden. Die Software-Limitierungen betreffen den Einsatz im Lehrbetrieb und können für die Dauer von 10 Tagen zu Testzwecke anonym freigeschaltet werden. 0/1-SimWare bietet zahlreiche Lizenzierungsmodelle an, um die Software sowohl als rechnergebundene Einzelplatzversion als auch als verteilbare, rechnerungebundene Vollversion einzusetzen. Die kostenpflichtige Vollversion richtet sich an Privat- und Einzelanwender, Gymnasien, Berufsschulen, Fachhochschulen und Universitäten für den Einsatz in Ausbildung und Lehre, die bereits von einigen deutschen Bildungsinstituten für den Einsatz in der Lehre lizenziert wurde. Die Lehrsoftware liegt unter ''www.mikrocodesimulator.de'' zum Download bereit.

== Funktionsweise und -umfang ==
Das Programm ermöglicht den schrittweisen Aufbau einer virtuellen Applikation, die in ihrer Funktionalität unveränderbar vorgegeben ist. Im Erkundungsmodus kann die Funktionsweise und Steuerungsmöglichkeit neu hinzugefügter Komponenten innerhalb eines Mikrocode-Befehlszyklus in Erfahrung gebracht werden. Die Breite der von MikroSim unterstützten Mikrobefehle umfasst 49 Bit. Ein Mikrobefehl wird in drei Teilphasen eines 3-Phasentakts abgearbeitet. Die Teilphasen werden als Hol-, Rechen- und Bringphase bezeichnet und bewirken das Holen eines 32 Bit breiten Registerwerts, das Ausführen einer 32-Bit-Berechnung, und das abschließende Speichern des Rechenergebnisses in einem CPU-internen [[Register (Computer)|Register]].

Im Simulationsmodus können hintereinander ausgeführte Mikrobefehle die zentrale Recheneinheit des Simulators steuern, wobei jeder Mikrobefehl auf die Adresse des nächsten Mikrobefehls verweist. Der Mikrobefehlssatz, gemeinhin als „Mikrocode“ der Recheneinheit bezeichnet, umfasst in der gegenwärtigen Implementierung von MikroSim 1024 49-Bit-lange Mikrobefehle. Strukturierungsmöglichkeiten im adressierbaren Ablaufplan im Mikrocode und die Entwicklung eines zyklisch arbeitenden, mikrocodeprogrammierten [[Interpreter]]s für Operationscodes (kurz [[Opcode]]s) ermöglichen die Implementierung von einzelnen mikrocodeprogrammierten Mikrobefehlssequenzen. Diese können als mikroprogrammierte [[Maschinenbefehl]]e aufgefasst werden. Der Mikrocode kann als [[Firmware]] für MikroSim als Mikrocode-[[Read-Only Memory|ROM]]-Datei (ROM, engl. {{lang|en|Read-Only Memory}}) abgelegt, modifiziert und erneut geladen werden.

Innerhalb eines Mikrobefehlzyklus kann sowohl die CPU als auch ein Ein-Ausgabe-Kontroller auf einen externen 16 kB umfassenden [[Random-Access Memory|RAM]]-[[Datenspeicher]] (RAM, engl. {{lang|en|Random-Access Memory}}) zurückgreifen. Über den Ein-Ausgabe-Kontroller erfolgt die Kommunikation mit angeschlossenen Ein- und Ausgabekomponenten mit [[Direct Memory Access|DMA]]-, [[I2C|I2C]]- und [[Interrupt Request|IRQ]]-Funktionalität. Unterstützt werden ein Ausgabe-Port, eine Anzeige, ein Zeitgeber, ein Ereignis-Trigger, ein Digital-Analog-Wandler, eine Tastatur und Daten-Ein-Ausgabe-Kanäle.

Der Mikrocodesimulator verwendet acht frei verwendbare 32-Bit-Register, deren Inhalt für vorzeichenbehaftete und vorzeichenlose Ganzzahlberechnungen, sowie für 32-Bit-Gleitkommaarithmetik eingesetzt werden. Mit einem übersichtlichen Systemzahleditor können die Registerinhalte betrachtet und modifiziert werden.

Die zentrale Recheneinheit des Simulators, die 32-Bit-[[Arithmetisch-logische Einheit|ALU]], unterstützt 128 verschiedene, grundlegende Rechenoperationen für Ganzzahlen und Interrupt-Steuerung bis hin zur [[Gleitkommaarithmetik]], die als erstes in vergleichbarer Weise bereits von [[Konrad Zuse]] eingeführt wurde. Zur Verdeutlichung dieser Arithmetik stehen elementare Rechenoperationen für die schrittweise auflösbare Gleitkomma-Registeroperationen in Mantisse und Exponent von den Grundberechnungen Addition/Subtraktion und Multiplikation/Division zur Verfügung. Weiterführend werden darauf aufbauend mächtigere 32-Bit-Rechenbefehle der Gleitkommaarithmetik in Mantisse und Exponent für die Grundrechenarten und elementarer analytischer Funktionen bereitgestellt, wie sie in mathematischen [[Coprozessor]]en realisiert sind. Dabei wird idealisiert angenommen, dass jede der 128 unterstützten ALU-Rechenoperationen für die Ausführung nur einen virtuellen Rechentakt benötigt.

Die Mikrobefehle können auf verschiedenen Simulationsniveaus ausgeführt werden:
* In dem niedrigsten Simulationsniveau unterstützt der Simulator die phasenweise Abarbeitung eines Mikrobefehls, der in eine sogenannte Hol-, Rechen- und Bring-Phase unterteilt ist. Die Abarbeitung der Teilphasen ist mit einer einstellbaren Verzögerung zur besseren Nachverfolgung möglich.
* Darauf aufbauend ist die komplette Abarbeitung eines Mikrobefehls in einem Dreiphasen-Takt ohne Verzögerung möglich. Ebenso die Abarbeitung mehrerer zu einem Maschinenbefehl zusammenfassbarer Mikrobefehle mittels eines in Mikrocode programmierten Maschinencodeinterpreters. Der Interpreter hat die Aufgabe, Maschinensprachebefehle, als Operationscodes in einem Byte-Wert codiert, aus dem RAM zu holen und an die entsprechende Mikrocodeunterprogrammadresse zur mikroprogrammierten Ausführung zu verzweigen.
* Darüber hinaus ist die Abarbeitung mehrerer Maschinenbefehle bis zu einem frei definierbaren Haltepunkt möglich. Dabei kann die Zeit bis zum Erreichen des Halte-Punkts für Simulationsoptimierungen gestoppt werden.
* Im höchsten Simulationsniveau kann der Mikrocodesimulator im Freilauf-Modus ohne jegliche Unterbrechung Maschinensprachesequenzen abarbeiten und somit die Interaktion der Applikation mit Ein- und Ausgabeschnittstellen in den Vordergrund rücken.

Mit verschiedenen Zusatzoptionen können visuelle CPU-Aktivitäten zu Gunsten der Steigerung der Abarbeitungsgeschwindigkeit unterdrückt werden, so dass die Maschinenprogrammierung der virtuellen Applikation in den Vordergrund tritt.
Mit dem Performance-Index-Monitor bietet der Simulator die Möglichkeit, die Abarbeitungsgeschwindigkeit und Ausführungsdauer entworfener Mikrobefehl-Sequenzen zu bestimmen und diese in Bezug zur Rechenleistung, gemessen in Gleitkommaoperationen pro Sekunde (FLOPS, engl. {{lang|en|[[Floating Point Operations Per Second]]}}) und [[Instruktionen pro Sekunde|Maschinen-/Mikrobefehle pro Sekunde]] (MIPs, engl. {{lang|en|Million Instructions per Second}}), der verwendeten Simulationshardware zu setzen.

Mit dem Zusatzprogramm MikroBAT, dem sogenannten „Basic Assembler Tool“ für MikroSim, können einfache Programme in [[Assembler (Informatik)|Assembler]] erstellt werden. Dabei wird der Befehlsumfang unterstützter [[Mnemonic]]s durch den Satz eigener mikrocodeprogrammierter Maschinenbefehle (Opcode) bestimmt. Das Zusatzprogramm ist in der Lage, das Assembler-Programm in Maschinencodes zu übersetzen und in den externen Datenspeicher für anschließende Simulationen zu übertragen.
Zusammen mit MikroBAT behandelt der Mikrocodesimulator in didaktisch aufbauender Weise Lehraspekte der technischen Informatik vom schaltergesteuerten Rechenautomaten bis zur Assembler programmierbaren Applikation.

== Literatur ==
* H.P.Gumm, M.Sommer: ''Einführung in die Informatik'', 8. Auflage. Oldenbourg, München 2009, ISBN 978-3-486-58724-1, (Zu MikroSim insbesondere Kap. 5.6, S.470-485.)

== Weblinks ==
* [http://www.mikrocodesimulator.de Mikrocodesimulator MikroSim] – Offizielle Website

== Einzelnachweise ==
<references />

[[Kategorie:Virtualisierung]]
[[Kategorie:Lernsoftware]]
[[Kategorie:Rechnerarchitektur]]
[[Kategorie:Assembler]]
[[Kategorie:Technische Informatik]]

[[en:MikroSim]]

Mikrobefehl

2011-01-11T07:52:46Z

SimDoc: /* Funktionsweise */ Verweise eingebunden

Der '''Mikrobefehl''' ist eine elementare Anweisung zur [[Steuerung]] eines [[Mikroprogrammsteuerwerk]]s, welches zur Steuerung eines [[Rechenwerk]]s in [[Mikroprozessor]]en und [[Mikrocontroller]]n integriert ist. Mehrere Mikrobefehle werden zu einem Mikrocodebefehlssatz zusammengefasst, der umgangssprachlich als [[Mikrocode]] eines Mikroprogrammsteuerwerks bezeichnet wird.

== Funktionsweise ==
Durch eine [[inhärent]] codierte Adressierungsvorschrift in einem Teil des Mikrobefehls wird auf den nächsten zu verarbeitenden Mikrobefehl innerhalb eines adressierbaren Mikrobefehlssatzes verwiesen, so dass strukturierte Abläufe in sich wiederholenden Mikrobefehlssequenzen programmiert werden können. Auf diese Weise ist es möglich, den komplexen Befehlsumfang eines [[Complex Instruction Set Computer|CISC-Prozessors]] (CISC, {{lang|enS|Complex Instruction Set Computer}}) als Mikrobefehlssequenz darzustellen. Der Mikrobefehlssatz kann somit als [[Firmware]] des Mikroprogrammsteuerwerks verstanden werden. Der Mikrocode eines integrierten Rechenwerks befindet sich in einem abgetrennten Speicherbereich mit kurzer Zugriffszeit. Der Mikrocode fungiert als niedrigstes Steuerprogramm, programmiert in der Sprache der Mikrobefehle, um [[Maschinensprache|Maschinenbefehle]] in eine Reihe von Schaltoperationsanweisungen zu übersetzen.

Der Mikrobefehl besteht aus einer Aneinanderreihung von Bits, die bei der Abarbeitung innerhalb eines Mikrocodebefehlszyklus die Steuerung im Mikrocodeprogrammsteuer- und Rechenwerk bewirken. Dabei kann jedes einzelne Bit als diskrete Schaltanweisung (Pikobefehl) verstanden werden, die eine Schaltaktivität je nach Bit-Wert einleitet oder unterbindet. Alternativ können mehrere nicht unabhängige Bits in Bitfelder gruppiert als codierte Binärzahl ([[Nanocode]]) aufgefasst werden. Deren Bitkombination kann unter Umständen [[Multiplexer]]-Schaltungen dazu anweisen, zugeordnete Steuer- oder Rechenschaltungen ([[Nanoprogramm]]) zu aktivieren.

Ein Mikrobefehl(-santeil) wird als „''horizontal mikrobefehlscodiert''“ bezeichnet, wenn die Ausführung des Befehlsanteils mit unabhängiger Einzelbit-Steuermöglichkeit innerhalb eines Abarbeitungstakts erfolgt. In diesem Fall ist der Zustandsübergang des Rechenautomaten unabhängig von der Ausführungsreihenfolge der Schaltanweisungen innerhalb eines Mikrobefehls.

Ein Mikrobefehl(-santeil) wird als „''vertikal mikrobefehlscodiert''“ bezeichnet, wenn die Ausführung des Befehlsanteils aufgrund einer abhängigen Einzelbit-Steuermöglichkeit in Zwischentakten erfolgt (Nanoprogramm). Auf diese Weise kann eine zeitliche Abfolge von ineinandergreifenden Einzelbit-Steuerungen ausgenutzt oder eine Auswertung einer bitgruppierierungsabhängigen Steuerung ermöglich werden. In diesem Fall ist der Zustandsübergang des Rechenautomaten abhängig von der Ausführungsreihenfolge der Schaltanweisungen innerhalb eines Mikrobefehls.

Besteht ein Mikrobefehl aus horizontal wie auch vertikal codierten Anteilen, so bezeichnet man diesen auch als "''diagonal mikrobefehlscodiert''".

Ein Mikrobefehlszyklus kann in mehrere Phasen unterteilt sein, in denen horizontal und vertikal mikrobefehlscodierte Steuerungsanweisungen gleichzeitig aktiv sind. Ist der Mikrocode-Speicherbereich veränderbar, so kann ein Mikrocode-Programm (auch Mikroprogramm) nachträglich verändert und geladen werden um Hardware-Funktionalitäten anzupassen, zu korrigieren oder zu optimieren.

Ein aus Mikrobefehlen (engl. ''Micro Instruction'') in Binärcode zusammengestelltes Mikroprogramm wird als [[Mikrocode]] (engl.''Microcode'') bezeichnet. Das Vorgehen bei der Programmierung im Sinne der Zusammenstellung der Mikrobefehle zu einem Mikroprogramm wird als [[Mikroprogrammierung]] bezeichnet, die unmittelbare Erstellung eines Steuerprogramms in Binärcode als Mikrocodierung (engl. ''Microcoding''). Gegebenenfalls werden Programmierwerkzeuge verwendet, die als [[Mikroassembler]] (engl. ''Microassembler'') bezeichnet werden. Mit diesen Hilfsmitteln ist es möglich, auf übersichtliche Weise Mikrobefehlssequenzen zu verwalten und diese in Binärcode zu übersetzen. Die Bedeutung der Mikrobefehle für die Steuerung einer virtuellen Recheneinheit wird mit dem Mikrocodesimulator [[MikroSim]] auf didaktische Weise vermittelt.

== Literatur ==
* {{cite book | author= H. P. Gumm, M. Sommer | title=Einführung in die Informatik | publisher=Oldenbourg, 8. Auflage |year=2009 |isbn=978-3-486-58724-1}}
* {{cite book | author= K. Wüst| title=Mikroprozessortechnik: Grundlagen, Architekturen und Programmierung von Mikroprozessoren, Mikrocontrollern und Signalprozessoren | publisher=Vieweg+Teubner Verlag, 3. Auflage |year=2008 |isbn=978-3-834-80461-7}}
* {{cite book | author= H. Bähring| title=Mikrorechner-Technik, Band 1, Mikroprozessoren und Digitale Signalprozessoren | publisher=Springer, 3. Auflage |year=2002 |isbn=3-540-41648-x}}
* {{cite book | author= H. Bähring| title=Mikrorechner-Technik, Band 2, Busse, Speicher, Peripherie und Mikrocontroller| publisher=Springer, 3. Auflage |year=2002 |isbn=3-540-43693-6}}
* {{cite book | author= Bringschulte, Ungerer| title=Mikrocontroller und Mikroprozessoren| publisher=Springer |year=2002 |isbn=3-540-43095-4}}

== Weblinks ==
* {{cite web|url=http://www.mikrocodesimulator.de/ |title=Mikrocodesimulator MikroSim 2010 |publisher=0/1-SimWare |date= |accessdate=2010-10-03}}
* {{cite web|url=http://www.stéen.se/share/unix/kernel/microcode/microcode.pdf
|title=P6 Family Processor Microcode Update, Feature Review |publisher=J. Molina, W. Arbaugh |year=2000 |accessdate=2010-10-03}}
* {{cite web|url=http://www.cs.clemson.edu/~mark/uprog.html
|title=A Brief History of Microprogramming|publisher=M. Smotherman |year=2010 |accessdate=2010-10-03}}
* {{cite web|url=http://research.microsoft.com/en-us/um/people/gbell/Computer_Structures_Principles_and_Examples/csp0167.htm
|title=Computer Structures: Principles and Examples, Part 2, REGIONS OF COMPUTER SPACE, Section 1, MICROPROGRAM-BASED PROCESSORS, Seite 151 ff. |publisher=McGraw-Hill Computer Science Series |accessdate=2010-10-03}}
* {{cite web|url=http://www.intel.com/Assets/PDF/manual/253668.pdf |title=Intel(R) 64 and IA-32 Architectures Software Developer’s Manual, Volume 3A: System Programming Guide, Part 1, Chapter 9.11: "Microcode update facilities"|publisher=Intel Cooperation |date=December 2009 |accessdate=2010-10-03}}
* {{cite web|url=http://urbanmyth.org/microcode/ |title=Intel Microcode Update Utility for Linux|accessdate=2010-10-03}}
* {{cite web|url=http://support.microsoft.com/kb/936357 |title=A microcode reliability update is available that improves the reliability of systems that use Intel processors|Microsoft|accessdate=2010-10-03}}
* {{cite web|url=http://www.intel.com/support/motherboards/server/sb/cs-021619.htm| title=BIOS Update required when Missing Microcode message is seen during POST |publisher=Intel Cooperation |accessdate=2010-10-03}}

[[Kategorie:Rechnerarchitektur]]
[[Kategorie:Firmware]]
[[Kategorie:Assembler]]

[[en:Micro-operation]]
[[it:Micro operazioni]]
[[simple:Micro-operation]]

MikroSim

2010-12-21T11:27:01Z

SimDoc: Link zu Registertransferebene

Das Programm '''MikroSim''' ist eine [[Lernsoftware]] für das [[Betriebssystem]] [[Microsoft Windows]] zur hardware-unspezifischen Erläuterung der allgemeinen Funktionsweise und Steuerabläufe einer virtuellen Rechenmaschine. Es lassen sich in allgemein verständlicher Weise miniaturisierte [[Rechenwerk]]e didaktisch auf [[Registertransferebene]] erläutern, die in [[Mikrocontroller]]n, [[Prozessor (Hardware)|Prozessoren]], und [[Computer]]n ablaufen.

== Allgemeines ==
Anfänglich wurde MikroSim als Prozessor-Simulationssoftware konzipiert. Da MikroSim allerdings die [[Mikroprogrammierung|Mikrocode-Programmierung]] eines [[Mikroprogrammsteuerwerk]]s mittels [[Mikrobefehl]]en in den Vordergrund stellt, betont die Anwendung primär die Mikrocodesimulation. In der gegenwärtigen Entwicklung erlangt der [[Simulator]] den Status einer virtuellen Applikation. Dabei werden allgemeine Prinzipien der System- und [[Rechnerarchitektur]] aufgegriffen, die sich mit dem Beginn des [[Informationszeitalter]]s etabliert haben und noch heute bestand haben, ohne sich auf spezielle Hardwareaspekte zu beschränken. Auf diese Weise erlangt das Simulationswerkzeug einen zeitlosen, freien didaktischen Nutzen, ohne sich auf spezielle vergangene und zukünftige Entwicklungen festzulegen. Die detaillierte Dokumentation und die zweisprachige Benutzerführung der [[E-Learning]]-Anwendung in Deutsch und Englisch, sowie die Auslegung der Software für die weithin verbreiteten Windows-Betriebssysteme, ist der Grund für den nachhaltigen Bestand der Software im Lehrbetrieb auf dem Gebiet der [[technische Informatik|technischen Informatik]] in Ausbildung und Lehre seit 1992.

== Entwicklungsgeschichte ==
Die Software basiert auf einer freien, unter [[Turbo-Pascal]] für das Betriebssystem [[MS-DOS]] geschriebenen Programmversion, die bis 1992 an der [[Philipps-Universität Marburg]] in der Vorlesung zur technischen Informatik für die Erläuterung von Mikrocodesteuerprozessen herangezogen wurde. Das bis dahin etablierte didaktische Vorlesungskonzept wurde im Sommer 1992 von Martin Perner während seines Physik-[[Diplom]]studiums (1990–1995) aufgegriffen und in freier Arbeit auf das Betriebssystem [[Microsoft Windows 3.x|Windows 3.1]] unter [[Visual Basic]] 1.0 portiert. Dabei entstand der Simulator in einer für damalige Verhältnisse völlig neuartigen Konzeption mit weitreichender Funktionalitätsverbesserung. Die Weiterentwicklung der Lehrsoftware unter Windows wurde bis 1995 von dem Fachbereich Mathematik/Informatik der Universität Marburg durch Heinz-Peter Gumm gefördert. Der Simulator wurde im November 1994 mit dem ''Europäischen Hochschul-Software-Preis 1994'' in der Kategorie [[Informatik]] in [[Heidelberg]] ausgezeichnet und im März 1995 auf der Computermesse [[CeBit]] in Hannover am Stand der hessischen Hochschulen der Öffentlichkeit vorgestellt.

Im Zeitraum Ende 1995 bis Anfang 2000 wurde der Simulator mit wenigen Verbesserungen unter der Revision MikroSim 1.2 veröffentlicht. In diesem Zeitraum wurde MikroSim im Rahmen des ''Europäischen Jahres des lebensbegleitenden Lernens 1996'' mit 1000 ECU prämiert, sowie beim Wettbewerb ''Multimedia Transfer'97'' im Rahmen der Messe ''LearnTec’97'' vorgestellt.<ref>[http://www.mikrocodesimulator.de/index.php#PreiseAuszeichnungen Preise und Auszeichnungen] auf der MikroSim-Website (Abgerufen am 5. November 2010.)</ref> In seiner vorletzten Neuauflage wurde der Simulator unter dem Namen „Mikrocodesimulator MikroSim2000“ mittels der Programmiersprache MS-Visual Basic 4.0 für [[Microsoft Windows 95|Windows 95]] angepasst.

Im Zeitraum Anfang 2008 bis 2009 erfuhr der Simulator weitreichende konzeptionelle Erweiterungen, ohne die Möglichkeiten der Mikrocodesimulation im Kern zu verändern. Dabei wird die Rechenleistung heutiger Windows-Applikationen und der verwendeten Hardware ausgenutzt, um Simulationen bis hin zur virtuellen Applikation zu ermöglichen. Seit Januar 2010 wird der Simulator unter „Mikrocodesimulator MikroSim 2010“ von 0/1-SimWare vertrieben.

== Kompatibilität ==
Die Software ist aus Kompatibilitätsgründen und zum Zweck einer möglichst weiten Verbreitung als 32-Bit-Version kompiliert und für [[Microsoft Windows XP|Windows XP]] optimiert worden. Das Programm kann auf allen 32- und 64-Bit-Betriebssystem der Versionen [[Microsoft Windows Vista| Windows Vista]] und [[Microsoft Windows 7|Windows 7]] ausgeführt werden. Auf spezielle XP-Kompatibilitätsmodi kann hierbei verzichtet werden.

== Lizenzierung und Bezug ==
Die MikroSim kann als frei verteilbare und kostenlose Demoversion mit Einschränkungen in der Funktionalität verwendet werden. Die Software-Limitierungen betreffen den Einsatz im Lehrbetrieb und können für die Dauer von 10 Tagen zu Testzwecke anonym freigeschaltet werden. 0/1-SimWare bietet zahlreiche Lizenzierungsmodelle an, um die Software sowohl als rechnergebundene Einzelplatzversion als auch als verteilbare, rechnerungebundene Vollversion einzusetzen. Die kostenpflichtige Vollversion richtet sich an Privat- und Einzelanwender, Gymnasien, Berufsschulen, Fachhochschulen und Universitäten für den Einsatz in Ausbildung und Lehre, die bereits von einigen deutschen Bildungsinstituten für den Einsatz in der Lehre lizenziert wurde. Die Lehrsoftware liegt unter ''www.mikrocodesimulator.de'' zum Download bereit.

== Funktionsweise und -umfang ==
Das Programm ermöglicht den schrittweisen Aufbau einer virtuellen Applikation, die in ihrer Funktionalität unveränderbar vorgegeben ist. Im Erkundungsmodus kann die Funktionsweise und Steuerungsmöglichkeit neu hinzugefügter Komponenten innerhalb eines Mikrocode-Befehlszyklus in Erfahrung gebracht werden. Die Breite der von MikroSim unterstützten Mikrobefehle umfasst 49 Bit. Ein Mikrobefehl wird in drei Teilphasen eines 3-Phasentakts abgearbeitet. Die Teilphasen werden als Hol-, Rechen- und Bringphase bezeichnet und bewirken das Holen eines 32 Bit breiten Registerwerts, das Ausführen einer 32-Bit-Berechnung, und das abschließende Speichern des Rechenergebnisses in einem CPU-internen [[Register (Computer)|Register]].

Im Simulationsmodus können hintereinander ausgeführte Mikrobefehle die zentrale Recheneinheit des Simulators steuern, wobei jeder Mikrobefehl auf die Adresse des nächsten Mikrobefehls verweist. Der Mikrobefehlssatz, gemeinhin als „Mikrocode“ der Recheneinheit bezeichnet, umfasst in der gegenwärtigen Implementierung von MikroSim 1024 49-Bit-lange Mikrobefehle. Strukturierungsmöglichkeiten im adressierbaren Ablaufplan im Mikrocode und die Entwicklung eines zyklisch arbeitenden, mikrocodeprogrammierten [[Interpreter]]s für Operationscodes (kurz [[Opcode]]s) ermöglichen die Implementierung von einzelnen mikrocodeprogrammierten Mikrobefehlssequenzen. Diese können als mikroprogrammierte [[Maschinenbefehl]]e aufgefasst werden. Der Mikrocode kann als [[Firmware]] für MikroSim als Mikrocode-[[Read-Only Memory|ROM]]-Datei (ROM, engl. {{lang|en|Read-Only Memory}}) abgelegt, modifiziert und erneut geladen werden.

Innerhalb eines Mikrobefehlzyklus kann sowohl die CPU als auch ein Ein-Ausgabe-Kontroller auf einen externen 16 kB umfassenden [[Random-Access Memory|RAM]]-[[Datenspeicher]] (RAM, engl. {{lang|en|Random-Access Memory}}) zurückgreifen. Über den Ein-Ausgabe-Kontroller erfolgt die Kommunikation mit angeschlossenen Ein- und Ausgabekomponenten mit [[Direct Memory Access|DMA]]-, [[I2C|I2C]]- und [[Interrupt Request|IRQ]]-Funktionalität. Unterstützt werden ein Ausgabe-Port, eine Anzeige, ein Zeitgeber, ein Ereignis-Trigger, ein Digital-Analog-Wandler, eine Tastatur und Daten-Ein-Ausgabe-Kanäle.

Der Mikrocodesimulator verwendet acht frei verwendbare 32-Bit-Register, deren Inhalt für vorzeichenbehaftete und vorzeichenlose Ganzzahlberechnungen, sowie für 32-Bit-Gleitkommaarithmetik eingesetzt werden. Mit einem übersichtlichen Systemzahleditor können die Registerinhalte betrachtet und modifiziert werden.

Die zentrale Recheneinheit des Simulators, die 32-Bit-[[Arithmetisch-logische Einheit|ALU]], unterstützt 128 verschiedene, grundlegende Rechenoperationen für Ganzzahlen und Interrupt-Steuerung bis hin zur [[Gleitkommaarithmetik]], die als erstes in vergleichbarer Weise bereits von [[Konrad Zuse]] eingeführt wurde. Zur Verdeutlichung dieser Arithmetik stehen elementare Rechenoperationen für die schrittweise auflösbare Gleitkomma-Registeroperationen in Mantisse und Exponent von den Grundberechnungen Addition/Subtraktion und Multiplikation/Division zur Verfügung. Weiterführend werden darauf aufbauend mächtigere 32-Bit-Rechenbefehle der Gleitkommaarithmetik in Mantisse und Exponent für die Grundrechenarten und elementarer analytischer Funktionen bereitgestellt, wie sie in mathematischen [[Coprozessor]]en realisiert sind. Dabei wird idealisiert angenommen, dass jede der 128 unterstützten ALU-Rechenoperationen für die Ausführung nur einen virtuellen Rechentakt benötigt.

Die Mikrobefehle können auf verschiedenen Simulationsniveaus ausgeführt werden:
* In dem niedrigsten Simulationsniveau unterstützt der Simulator die phasenweise Abarbeitung eines Mikrobefehls, der in eine sogenannte Hol-, Rechen- und Bring-Phase unterteilt ist. Die Abarbeitung der Teilphasen ist mit einer einstellbaren Verzögerung zur besseren Nachverfolgung möglich.
* Darauf aufbauend ist die komplette Abarbeitung eines Mikrobefehls in einem Dreiphasen-Takt ohne Verzögerung möglich. Ebenso die Abarbeitung mehrerer zu einem Maschinenbefehl zusammenfassbarer Mikrobefehle mittels eines in Mikrocode programmierten Maschinencodeinterpreters. Der Interpreter hat die Aufgabe, Maschinensprachebefehle, als Operationscodes in einem Byte-Wert codiert, aus dem RAM zu holen und an die entsprechende Mikrocodeunterprogrammadresse zur mikroprogrammierten Ausführung zu verzweigen.
* Darüber hinaus ist die Abarbeitung mehrerer Maschinenbefehle bis zu einem frei definierbaren Haltepunkt möglich. Dabei kann die Zeit bis zum Erreichen des Halte-Punkts für Simulationsoptimierungen gestoppt werden.
* Im höchsten Simulationsniveau kann der Mikrocodesimulator im Freilauf-Modus ohne jegliche Unterbrechung Maschinensprachesequenzen abarbeiten und somit die Interaktion der Applikation mit Ein- und Ausgabeschnittstellen in den Vordergrund rücken.

Mit verschiedenen Zusatzoptionen können visuelle CPU-Aktivitäten zu Gunsten der Steigerung der Abarbeitungsgeschwindigkeit unterdrückt werden, so dass die Maschinenprogrammierung der virtuellen Applikation in den Vordergrund tritt.
Mit dem Performance-Index-Monitor bietet der Simulator die Möglichkeit, die Abarbeitungsgeschwindigkeit und Ausführungsdauer entworfener Mikrobefehl-Sequenzen zu bestimmen und diese in Bezug zur Rechenleistung, gemessen in Gleitkommaoperationen pro Sekunde (FLOPS, engl. {{lang|en|[[Floating Point Operations Per Second]]}}) und [[Instruktionen pro Sekunde|Maschinen-/Mikrobefehle pro Sekunde]] (MIPs, engl. {{lang|en|Million Instructions per Second}}), der verwendeten Simulationshardware zu setzen.

Mit dem Zusatzprogramm MikroBAT, dem sogenannten „Basic Assembler Tool“ für MikroSim, können einfache Programme in [[Assembler (Informatik)|Assembler]] erstellt werden. Dabei wird der Befehlsumfang unterstützter [[Mnemonic]]s durch den Satz eigener mikrocodeprogrammierter Maschinenbefehle (Opcode) bestimmt. Das Zusatzprogramm ist in der Lage, das Assembler-Programm in Maschinencodes zu übersetzen und in den externen Datenspeicher für anschließende Simulationen zu übertragen.
Zusammen mit MikroBAT behandelt der Mikrocodesimulator in didaktisch aufbauender Weise Lehraspekte der technischen Informatik vom schaltergesteuerten Rechenautomaten bis zur Assembler programmierbaren Applikation.

== Literatur ==
* H.P.Gumm, M.Sommer: ''Einführung in die Informatik'', 8. Auflage. Oldenbourg, München 2009, ISBN 978-3-486-58724-1, (Zu MikroSim insbesondere Kap. 5.6, S.470-485.)

== Weblinks ==
* [http://www.mikrocodesimulator.de Mikrocodesimulator MikroSim] – Offizielle Website

== Einzelnachweise ==
<references />

[[Kategorie:Virtualisierung]]
[[Kategorie:Lernsoftware]]
[[Kategorie:Rechnerarchitektur]]
[[Kategorie:Assembler]]
[[Kategorie:Technische Informatik]]

[[en:MikroSim]]

Mikroprogrammsteuerwerk

2010-12-20T07:05:16Z

SimDoc: En-Interwiki

Ein '''Mikroprogrammsteuerwerk''' ist der Teil ''mikroprogrammierter'' [[Hauptprozessor|Prozessoren]], der die Ausführung eines [[Maschinencode|Befehls]] im Prozessor steuert. Das Steuerwerk enthält eine Menge von Mikroprogrammen, die jeweils aus einer Liste von Steuersignalen bestehen, die das Verhalten von Prozessorelementen – zum Beispiel der [[Arithmetisch-logische Einheit|ALU]] und den [[Register (Computer)|Registern]] – regeln. Bei manchen Prozessoren können die Mikroprogramme auch nachträglich mittels [[Mikrocodeprogrammierung]] geändert werden. Man könnte die Mikroprogramme auch als [[Firmware]] der CPU bezeichnen.

== Funktionsweise ==
[[Maschinencode]]s müssen in einem Prozessor mittels sogenannter [[Mikrobefehl]]e in Steuersignale für die einzelnen Funktionseinheiten umgesetzt werden. Unter Umständen müssen dazu mehrere aufeinander folgende Verarbeitungsschritte ausgelöst werden, um die Funktion des Maschinencodes in Form einer Mikrobefehlssequenz zu realisieren.

Nehmen wir als Beispiel den Befehl ''ADD A,B'' eines fiktiven Prozessors, der die Inhalte der Register A und B addieren und das Ergebnis in das Register A zurückschreiben soll. Es könnte folgender Steuerablauf im Prozessor ablaufen: 

# Die [[Arithmetisch-logische Einheit|ALU]] wird für eine Addition konfiguriert.
# Der Inhalt von Register A wird an den ersten Eingang der ALU angelegt.
# Der Inhalt von Register B wird an den zweiten Eingang der ALU angelegt.
# Nach dem Ablauf der Durchlaufzeit für das Auslesen der Register A und B, sowie die Ausführung der Addition in der ALU wird das Ergebnis in ein Zwischenregister abgelegt.
# Der Inhalt von Register A wird mit dem Wert aus dem Zwischenregister überschrieben.
# Der nächste Befehl wird aus dem Speicher gelesen.
Denkbar wäre, die Schritte 1, 2, 3 und 5, 6 in jeweils einem Zeitintervall zusammengefasst ablaufen zu lassen.

Um diesen Ablauf zu steuern ist es möglich, eine Logik aufzubauen, die direkt diese Steuerung vornimmt. Der Nachteil bei dieser „festen Verdrahtung“ der Befehle ist die Komplexität der notwendigen Logik und die geringe Flexibilität bei notwendigen Veränderungen.

Im Falle der [[Mikroprogrammierung]] wird eine solche Ablaufsteuerung über die in einem Speicher abgelegten [[Mikroprogramm]]e realisiert. Der Maschinencode aktiviert dabei jeweils eines der Mikroprogramme, das in mehreren Schritten dann jeweils alle notwendigen Steuersignale für die Funktionseinheiten erzeugt. Im einfachsten Falle ist das Mikroprogrammsteuerwerk aufgebaut aus einem Befehlsregister, das den gerade ausgeführten Maschinencode enthält, einem Zähler für die Mikroprogrammschritte und einem Speicher, der die einzelnen Schritte enthält. Das Befehlsregister und der Zähler zusammen ergeben dann die Adresse für den Mikroprogrammspeicher. Es sind aber auch komplexere Mikroprogrammsteuerwerke möglich, die Sprungbefehle und Verzweigungen ausführen können, um komplexere Befehle zu ermöglichen. Die Bedeutung eines Mikroprogrammsteuerwerks als Leitwerk für die Steuerung eines virtuellen Rechenwerks wird mit dem Mikrocodesimulator [[MikroSim]] auf didaktische Weise vermittelt.

== Entwicklung ==
Frühe Prozessoren waren typischerweise mit fest verdrahteter Logik aufgebaut, später wurden dann vermehrt Mikroprogrammsteuerwerke eingesetzt. Diese Entwicklung hat sich bei den [[Mainframe|Mainframe-Computern]], wie auch später bei den [[Mikroprozessor]]en abgespielt. Mit der Entwicklung zu immer höheren Taktfrequenzen und zu [[Reduced Instruction Set Computer|RISC]]-Prozessoren ging dann allerdings der Trend wieder zu fest verdrahteter Logik. Aktuelle Prozessoren verwenden oft eine Mischform, bei der häufig verwendete Befehle oder Befehlsteile mit fest verdrahteter Logik ausgeführt werden und komplexe, oder nicht so zeitkritische Befehle ganz oder teilweise mit Mikrocode.

Einige Prozessoren können ihre Mikroprogrammierung auch selbst dynamisch ändern, zum Beispiel um einen anderen [[Befehlssatz]] zu erlauben oder die Ausführung zu [[Optimierung|optimieren]]. In einigen Fällen kann ein Teil des fest in einem Prozessor verankerten Mikrocodes durch nachgeladenen Mikrocode ersetzt werden um Fehler im Prozessor zu kompensieren.

Mikroprogrammsteuerwerke sind eine Form von [[Speicherprogrammierbare Steuerung|speicherprogrammierbarer Steuerung]]. Ihr Einsatz ist nicht auf Prozessoren begrenzt.

== Literatur ==
*{{cite book | author= H.P. Gumm, M. Sommer | title=Einführung in die Informatik | publisher=Oldenbourg, 8. Auflage |year=2009 |isbn=978-3-486-58724-1}}
*{{cite book | author= K. Wüst| title=Mikroprozessortechnik: Grundlagen, Architekturen und Programmierung von Mikroprozessoren, Mikrocontrollern und Signalprozessoren | publisher=Vieweg+Teubner Verlag, 3. Auflage |year=2008 |isbn=978-3-834-80461-7}}
*{{cite book | author= H. Bähring| title=Mikrorechner-Technik, Band 1, Mikroprozessoren und Digitale Signalprozessoren | publisher=Springer, 3. Auflage |year=2002 |isbn=3-540-41648-x}}
*{{cite book | author= H. Bähring| title=Mikrorechner-Technik, Band 2, Busse, Speicher, Pheriperie und Mikrocontroller| publisher=Springer, 3. Auflage |year=2002 |isbn=3-540-43693-6}}
*{{cite book | author= Bringschulte, Ungerer| title=Mikrocontroller und Mikroprozessoren| publisher=Springer |year=2002 |isbn=3-540-43095-4}}
*{{cite book | author= R. Kelch| title=Rechnergrundlagen - Von der Binärlogik zum Schaltwerk| publisher=Fachbuchverlag Leipzig |year=2003 |isbn=3-446-22112-1}}
*{{cite book | author= R. Kelch| title=Rechnergrundlagen - Vom Rechenwerk zum Universalrechner| publisher=Fachbuchverlag Leipzig |year=2003 |isbn=3-446-22113-1}}
*{{cite book | author= Ch. Märtin| title=Einführung in die Rechnerarchitektur - Prozessoren und Systeme| publisher=Fachbuchverlag Leipzig |year=2003 |isbn=3-446-22242-1}}

== Weblinks ==
*{{cite web|url=http://www.mikrocodesimulator.de/ |title=Mikrocodesimulator MikroSim 2010 |publisher=0/1-SimWare |date= |accessdate=2010-10-03}}
*[http://daniel.netsniff-ng.org/microtowers/ Spiel Türme von Hanoi implementiert in einem Mikroprogrammsteuerwerk]



[[Kategorie:Rechnerarchitektur]]
[[Kategorie:Firmware]]
[[Kategorie:Technische Informatik]]

[[en:Control unit]]

Mikroprogrammierung

2010-12-20T07:03:34Z

SimDoc: EN-Interwiki

Als '''Mikroprogrammierung''' wird die Methode und das Vorgehen verstanden Schalt-, Rechen- und Steuerabläufe in einem [[Rechenwerk]], insbesondere einem integrierten Rechenwerk ([[Mikrocontroller]], [[Mikroprozessor]]) unterhalb der Ausführungsebene von [[Maschinenbefehl]]en auf Mikrobefehlsebene festzulegen und zu regeln. Als Mikroprogrammierung kann die Erstellung eines Mikrobefehlssatzes als Abfolge von Mikrobefehlsequenzen in einer Art Steuersprache für Schalter verstanden werden. Vereinzelt wird durch den Begriff ''Mikrocode-Programmierung oder Mikrocodeprogrammierung'' die Erstellung des sogenannten [[Mikrocode]]s bei der Mikroprogrammierung betont, der die Binärform des Mikrobefehlssatzes darstellt.

Mit der Mikrocodeprogrammierbarkeit eines Rechenwerks ist das Vorhandensein eines dazu angepassten [[Mikroprogrammsteuerwerk]]s verbunden, welches durch die taktweise Abfolge der Mikrocodebefehlssequenz gesteuert wird. Die Möglichkeit einer flexibel programmierbaren Abfolgesteuerung von Mikrobefehlen setzt voraus, dass in jedem [[Mikrobefehl]] (engl. ''Micro Instruction'') selbst eine Berechnungsvorschrift zum Verweis, d. h. [[Adressierung (Datenverarbeitung)|Adressierung]], auf den nächsten anzusteuernden Mikrobefehl enthalten ist.

Üblicherweise ist ein Maschinensprachebefehlssatz eines [[Prozessor (Hardware)|Prozessors]] bei der Fertigung (z. B aus Kompatibilitätsgründen) vorgegeben und nicht veränderbar. Der den Maschinencode bildende Mikrobefehlssatz (kurz Mikrocode) ist in einem [[Festwertspeicher]] wie [[EPROM]] oder [[ROM]] inner- oder außerhalb des Rechenwerks untergebracht und wird ggf. bei der [[Initialisierung]] des Rechenwerks in das Mikroprogrammsteuerwerk geladen. Zur Optimierung von Schaltungsabläufen werden dennoch Möglichkeiten vorgesehen und Vorkehrungen getroffen, dass ein Mikrocode korrigiert, verbessert oder angepasst werden kann, um kostspielige Neuentwürfe im Sinne eines Mikrocode-[[Bugfix]] zu umgehen. In den Anfängen der Mikroprozessor-Ära war die Möglichkeit einer flexiblen Mikrocodeprogrammierung unumgänglich und gewünscht, um einzelne zu einem Baustein-Neuentwurf führende Implementierungsfehler zu verhindern. Mit den Fortschritten in der [[Verifikation]] und Integrierbarkeit digitaler Schaltungen schien der Aspekt der Umprogrammierbarkeit einige Zeit lang an Bedeutung zu verlieren.

Dennoch hat das Interesse an der Umprogrammierbarkeit im Laufe der letzten Jahre eine Wiederbelebung erfahren. So sind Mikroprozessoren der Firma Intel ab dem Modell Pentium Pro (P6) im Mikrocode umprogrammierbar. Der als [[FDIV-Bug]] bekannt gewordene Rechenfehler auf einem Teil der Intel Pentium-P5-Prozessoren konnte hingegen nicht durch Mikrocodeprogrammierung behoben werden sondern nur durch Prozessoraustausch. Mit der Mikrocodeprogrammierung ist die Möglichkeit gegeben, Rechensteuerwerke mittels Mikrocode-[[Update]]s für spezielle Betriebssysteme zu optimieren.

Das Vorgehen bei der Programmierung im Sinne der Zusammenstellung der Mikrobefehle zu einem Mikroprogramm wird im englischsprachigen Raum als ''Microcoding'' bezeichnet. Dabei werden Programmierwerkzeuge verwendet, die als Mikroassembler (engl. ''Microassembler'') bezeichnet werden. Mit diesen Hilfsmitteln ist es möglich, auf übersichtliche Weise Mikrobefehlssequenzen zu verwalten und diese in Binärcode zu übersetzen. Die Lernsoftware Mikrocodesimulator [[MikroSim]] vermittelt auf didaktische Weise die Bedeutung und das praktische Vorgehen bei der Mikroprogrammierung einer virtuellen Recheneinheit.

== Literatur ==
*{{cite book | author= H.P. Gumm, M. Sommer | title=Einführung in die Informatik | publisher=Oldenbourg, 8. Auflage |year=2009 |isbn=978-3-486-58724-1}}
*{{cite book | author= K. Wüst| title=Mikroprozessortechnik: Grundlagen, Architekturen und Programmierung von Mikroprozessoren, Mikrocontrollern und Signalprozessoren | publisher=Vieweg+Teubner Verlag, 3. Auflage |year=2008 |isbn=978-3-834-80461-7}}
*{{cite book | author= H. Bähring| title=Mikrorechner-Technik, Band 1, Mikroprozessoren und Digitale Signalprozessoren | publisher=Springer, 3. Auflage |year=2002 |isbn=3-540-41648-x}}
*{{cite book | author= H. Bähring| title=Mikrorechner-Technik, Band 2, Busse, Speicher, Peripherie und Mikrocontroller| publisher=Springer, 3. Auflage |year=2002 |isbn=3-540-43693-6}}
*{{cite book | author= Bringschulte, Ungerer| title=Mikrocontroller und Mikroprozessoren| publisher=Springer |year=2002 |isbn=3-540-43095-4}}

== Weblinks ==
*{{cite web|url=http://www.mikrocodesimulator.de/ |title=Mikrocodesimulator MikroSim 2010 |publisher=0/1-SimWare |date= |accessdate=2010-10-03}}
*{{cite web|url=http://www.stéen.se/share/unix/kernel/microcode/microcode.pdf
|title=P6 Family Processor Microcode Update, Feature Review |publisher=J. Molina, W. Arbaugh |year=2000 |accessdate=2010-10-03}}
*{{cite web|url=http://www.cs.clemson.edu/~mark/uprog.html
|title=A Brief History of Microprogramming|publisher=M. Smotherman |year=2010 |accessdate=2010-10-03}}
*{{cite web|url=http://research.microsoft.com/en-us/um/people/gbell/Computer_Structures_Principles_and_Examples/csp0167.htm
|title=Computer Structures: Principles and Examples, Part 2, REGIONS OF COMPUTER SPACE, Section 1, MICROPROGRAM-BASED PROCESSORS, Seite 151 ff. |publisher=McGraw-Hill Computer Science Series |accessdate=2010-10-03}}
*{{cite web|url=http://www.intel.com/Assets/PDF/manual/253668.pdf |title=Intel(R) 64 and IA-32 Architectures Software Developer’s Manual, Volume 3A: System Programming Guide, Part 1, Chapter 9.11: "Microcode update facilities"|publisher=Intel Cooperation |date=December 2009 |accessdate=2010-10-03}}
*{{cite web|url=http://urbanmyth.org/microcode/ |title=Intel Microcode Update Utility for Linux|accessdate=2010-10-03}}
*{{cite web|url=http://support.microsoft.com/kb/936357 |title=A microcode reliability update is available that improves the reliability of systems that use Intel processors|Microsoft|accessdate=2010-10-03}}
*{{cite web|url=http://www.intel.com/support/motherboards/server/sb/cs-021619.htm| title=BIOS Update required when Missing Microcode message is seen during POST |publisher=Intel Cooperation |accessdate=2010-10-03}}

[[Kategorie:Systemsoftware]]
[[Kategorie:Rechnerarchitektur]]
[[Kategorie:Firmware]]
[[Kategorie:Technische Informatik]]

[[en:Microprogramming]]
[[fr:Microprogrammation]]
[[hr:Mikroprogramiranje]]
[[it:Microprogrammazione]]
[[sh:Mikroprogramiranje]]

Mikroprogramm

2010-12-20T07:01:34Z

SimDoc: EN-Interwiki

Das '''Mikroprogramm''' ist der Algorithmus eines [[Mikroprogrammsteuerwerk]]s in einem [[Prozessor]] zum Steuern seines [[Rechenwerk]]s. Mikroprogramme werden mittels [[Mikroprogrammierung]] erstellt. Die Mikrobefehle eines Mikroprogramms werden in einer adressierbaren Reihenfolge angeordnet und in einem [[Festwertspeicher]], dem sog. [[Mikroprogrammspeicher]], bereitgestellt. Die Mikrobefehle enthalten in binärer Form codierte Anweisungen mit fester Bit-Anzahl zur Aktivierung und Deaktivierung logischer Funktionseinheiten. Auf diese Weise bestimmt das Mikroprogrammsteuerwerk mit Hilfe des Mikroprogramms, welche Schaltvorgänge in welcher Reihenfolge zur Umsetzung von Maschinenbefehlen für ein Rechenwerk benötigt werden. Die Gesamtheit aller im Mikroprogrammspeicher binär codierten Mikrobefehle bilden den [[Mikrocode]].

Zusätzlich enthalten die Mikrobefehle eine inhärent codierte Adressierungsvorschrift, mit deren Hilfe der nächste anzusteuernde Mikrobefehl zur taktweisen, zyklischen Abarbeitung des Steuerablaufplans berechnet werden kann. Auf diese Weise ist es möglich, Mikrobefehle im Mikroprogramm nicht nur in aufsteigender Adressreihenfolge mit einfacher Sprungweite auszuführen, sondern ebenso in Adressierungssequenzen, die absolute, relative und bedingte Adressierungssprünge beinhalten können. Somit besteht die Möglichkeit einer möglichst redundanzfreien Strukturierung des Ablaufplans bzgl. sich wiederholender Mikrobefehlssequenzen. Somit besteht die Möglichkeit den begrenzt vorhandenen Mikrobefehlsspeicher in einer CPU für die Programmierung von Maschinenbefehlen in der Steuersprache der Mikrobefehle möglichst effektiv zu nutzen.

Das Mikroprogramm kann unmittelbar in Form binär codierter Mikrobefehle erstellt werden. Aber auch Hilfsmittel wie Mikroassembler können zur Mikroprogrammierung herangezogen werden, um die Steueranweisungen der Mikrobefehle eines Mikrocodeprogramms aus einer lesbaren Darstellung in die unübersichtliche binäre Mikrobefehlsform automatisiert zu übersetzen. Gleichzeitig kann mit dem [[Mikroassembler]] der Mikroprogrammspeicherinhalt und die inhärent codierte Adressierungsreihenfolge einer programmierten Mikrobefehlssequenz flexibel verwaltet werden. Die Erstellung eines Mikroprogramms zur Steuerung einer virtuellen Recheneinheit wird mit dem Mikrocodesimulator [[MikroSim]] auf didaktische Weise vermittelt.

== Literatur ==
*{{cite book | author= H.P. Gumm, M. Sommer | title=Einführung in die Informatik | publisher=Oldenbourg, 8. Auflage |year=2009 |isbn=978-3-486-58724-1}}
*{{cite book | author= K. Wüst| title=Mikroprozessortechnik: Grundlagen, Architekturen und Programmierung von Mikroprozessoren, Mikrocontrollern und Signalprozessoren | publisher=Vieweg+Teubner Verlag, 3. Auflage |year=2008 |isbn=978-3-834-80461-7}}
*{{cite book | author= H. Bähring| title=Mikrorechner-Technik, Band 1, Mikroprozessoren und Digitale Signalprozessoren | publisher=Springer, 3. Auflage |year=2002 |isbn=3-540-41648-x}}
*{{cite book | author= H. Bähring| title=Mikrorechner-Technik, Band 2, Busse, Speicher, Peripherie und Mikrocontroller| publisher=Springer, 3. Auflage |year=2002 |isbn=3-540-43693-6}}
*{{cite book | author= Bringschulte, Ungerer| title=Mikrocontroller und Mikroprozessoren| publisher=Springer |year=2002 |isbn=3-540-43095-4}}

== Weblinks ==
*{{cite web|url=http://www.mikrocodesimulator.de/ |title=Mikrocodesimulator MikroSim 2010 |publisher=0/1-SimWare |date= |accessdate=2010-10-03}}
*{{cite web|url=http://www.stéen.se/share/unix/kernel/microcode/microcode.pdf
|title=P6 Family Processor Microcode Update, Feature Review |publisher=J. Molina, W. Arbaugh |year=2000 |accessdate=2010-10-03}}
*{{cite web|url=http://www.cs.clemson.edu/~mark/uprog.html
|title=A Brief History of Microprogramming|publisher=M. Smotherman |year=2010 |accessdate=2010-10-03}}
*{{cite web|url=http://research.microsoft.com/en-us/um/people/gbell/Computer_Structures_Principles_and_Examples/csp0167.htm
|title=Computer Structures: Principles and Examples, Part 2, REGIONS OF COMPUTER SPACE, Section 1, MICROPROGRAM-BASED PROCESSORS, Seite 151 ff. |publisher=McGraw-Hill Computer Science Series |accessdate=2010-10-03}}
*{{cite web|url=http://www.intel.com/Assets/PDF/manual/253668.pdf |title=Intel(R) 64 and IA-32 Architectures Software Developer’s Manual, Volume 3A: System Programming Guide, Part 1, Chapter 9.11: "Microcode update facilities"|publisher=Intel Cooperation |date=December 2009 |accessdate=2010-10-03}}
*{{cite web|url=http://urbanmyth.org/microcode/ |title=Intel Microcode Update Utility for Linux|accessdate=2010-10-03}}
*{{cite web|url=http://support.microsoft.com/kb/936357 |title=A microcode reliability update is available that improves the reliability of systems that use Intel processors|Microsoft|accessdate=2010-10-03}}
*{{cite web|url=http://www.intel.com/support/motherboards/server/sb/cs-021619.htm| title=BIOS Update required when Missing Microcode message is seen during POST |publisher=Intel Cooperation |accessdate=2010-10-03}}

[[Kategorie:Systemsoftware]]
[[Kategorie:Rechnerarchitektur]]
[[Kategorie:Firmware]]
[[Kategorie:Technische Informatik]]

[[bs:Mikroprogram]]
[[en:Microprogram]]
[[fr:Microprogrammation]]
[[hr:Mikroprogramiranje]]
[[it:Microprogrammazione]]
[[pl:Mikroprogram]]
[[sh:Mikroprogramiranje]]
[[sr:Микропрограм]]
[[sv:Mikroprogram]]
[[tr:Mikroprogramlama]]

Mikrobefehl

2010-12-06T15:09:00Z

SimDoc: EN-Interwiki

Der '''Mikrobefehl''' ist eine elementare Anweisung zur [[Steuerung]] eines [[Mikroprogrammsteuerwerk]]s, welches zur Steuerung eines [[Rechenwerk]]s in [[Mikroprozessor]]en und [[Mikrocontroller]]n integriert ist. Mehrere Mikrobefehle werden zu einem Mikrocodebefehlssatz zusammengefasst, der umgangssprachlich als [[Mikrocode]] eines Mikroprogrammsteuerwerks bezeichnet wird.

== Funktionsweise ==
Durch eine [[inhärent]] codierte Adressierungsvorschrift in einem Teil des Mikrobefehls wird auf den nächsten zu verarbeitenden Mikrobefehl innerhalb eines adressierbaren Mikrobefehlssatzes verwiesen, so dass strukturierte Abläufe in sich wiederholenden Mikrobefehlssequenzen programmiert werden können. Auf diese Weise ist es möglich, den komplexen Befehlsumfang eines [[Complex Instruction Set Computer|CISC-Prozessors]] (CISC, {{lang|enS|Complex Instruction Set Computer}}) als Mikrobefehlssequenz darzustellen. Der Mikrobefehlssatz kann somit als [[Firmware]] des Mikroprogrammsteuerwerks verstanden werden. Der Mikrocode eines integrierten Rechenwerks befindet sich in einem abgetrennten Speicherbereich mit kurzer Zugriffszeit. Der Mikrocode fungiert als niedrigstes Steuerprogramm, programmiert in der Sprache der Mikrobefehle, um [[Maschinensprache|Maschinenbefehle]] in eine Reihe von Schaltoperationsanweisungen zu übersetzen.

Der Mikrobefehl besteht aus einer Aneinanderreihung von Bits, die bei der Abarbeitung innerhalb eines Mikrocodebefehlszyklus die Steuerung im Mikrocodeprogrammsteuer- und Rechenwerk bewirken. Dabei können einzelne Bits als diskrete Schalteranweisung verstanden werden, die eine Schaltaktivität je nach Bit-Wert einleitet oder unterbindet. Alternativ können mehrere nicht unabhängige Bits in Bitfelder gruppiert als codierte Binärzahl aufgefasst werden. Deren Bitkombination kann unter Umständen [[Multiplexer]]-Schaltungen dazu anweisen, eine zugeordnete Steuer- oder Rechenschaltung zu aktivieren.

Ein Mikrobefehl(-santeil) wird als „''horizontal mikrobefehlscodiert''“ bezeichnet, wenn die Ausführung des Befehlsanteils mit unabhängiger Einzelbit-Steuermöglichkeit innerhalb eines Abarbeitungstakts erfolgt. In diesem Fall ist der Zustandsübergang des Rechenautomaten unabhängig von der Ausführungsreihenfolge der Schaltanweisungen innerhalb eines Mikrobefehls.

Ein Mikrobefehl(-santeil) wird als „''vertikal mikrobefehlscodiert''“ bezeichnet, wenn die Ausführung des Befehlsanteils aufgrund einer abhängigen Einzelbit-Steuermöglichkeit in Zwischentakten erfolgt. Auf diese Weise kann eine zeitliche Abfolge von ineinandergreifenden Einzelbit-Steuerungen ausgenutzt oder eine Auswertung einer bitgruppierierungsabhängigen Steuerung ermöglich werden. In diesem Fall ist der Zustandsübergang des Rechenautomaten von der Ausführungsreihenfolge der Schaltanweisungen innerhalb eines Mikrobefehls abhängig.

Besteht ein Mikrobefehl aus horizontal wie auch vertikal codierten Anteilen, so bezeichnet man diesen auch als "''diagonal mikrobefehlscodiert''".

Ein Mikrobefehlszyklus kann in mehrere Phasen unterteilt sein, in denen horizontal und vertikal mikrobefehlscodierte Steuerungsanweisungen gleichzeitig aktiv sind. Ist der Mikrocode-Speicherbereich veränderbar, so kann ein Mikrocode-Programm (auch Mikroprogramm) nachträglich verändert und geladen werden um Hardware-Funktionalitäten anzupassen, zu korrigieren oder zu optimieren.

Ein aus Mikrobefehlen (engl. ''Micro Instruction'') in Binärcode zusammengestelltes Mikroprogramm wird als [[Mikrocode]] (engl.''Microcode'') bezeichnet. Das Vorgehen bei der Programmierung im Sinne der Zusammenstellung der Mikrobefehle zu einem Mikroprogramm wird als [[Mikroprogrammierung]] bezeichnet, die unmittelbare Erstellung eines Steuerprogramms in Binärcode als Mikrocodierung (engl. ''Microcoding''). Gegebenenfalls werden Programmierwerkzeuge verwendet, die als [[Mikroassembler]] (engl. ''Microassembler'') bezeichnet werden. Mit diesen Hilfsmitteln ist es möglich, auf übersichtliche Weise Mikrobefehlssequenzen zu verwalten und diese in Binärcode zu übersetzen. Die Bedeutung der Mikrobefehle für die Steuerung einer virtuellen Recheneinheit wird mit dem Mikrocodesimulator [[MikroSim]] auf didaktische Weise vermittelt.

== Literatur ==
*{{cite book | author= H. P. Gumm, M. Sommer | title=Einführung in die Informatik | publisher=Oldenbourg, 8. Auflage |year=2009 |isbn=978-3-486-58724-1}}
*{{cite book | author= K. Wüst| title=Mikroprozessortechnik: Grundlagen, Architekturen und Programmierung von Mikroprozessoren, Mikrocontrollern und Signalprozessoren | publisher=Vieweg+Teubner Verlag, 3. Auflage |year=2008 |isbn=978-3-834-80461-7}}
*{{cite book | author= H. Bähring| title=Mikrorechner-Technik, Band 1, Mikroprozessoren und Digitale Signalprozessoren | publisher=Springer, 3. Auflage |year=2002 |isbn=3-540-41648-x}}
*{{cite book | author= H. Bähring| title=Mikrorechner-Technik, Band 2, Busse, Speicher, Peripherie und Mikrocontroller| publisher=Springer, 3. Auflage |year=2002 |isbn=3-540-43693-6}}
*{{cite book | author= Bringschulte, Ungerer| title=Mikrocontroller und Mikroprozessoren| publisher=Springer |year=2002 |isbn=3-540-43095-4}}

== Weblinks ==
*{{cite web|url=http://www.mikrocodesimulator.de/ |title=Mikrocodesimulator MikroSim 2010 |publisher=0/1-SimWare |date= |accessdate=2010-10-03}}
*{{cite web|url=http://www.stéen.se/share/unix/kernel/microcode/microcode.pdf
|title=P6 Family Processor Microcode Update, Feature Review |publisher=J. Molina, W. Arbaugh |year=2000 |accessdate=2010-10-03}}
*{{cite web|url=http://www.cs.clemson.edu/~mark/uprog.html
|title=A Brief History of Microprogramming|publisher=M. Smotherman |year=2010 |accessdate=2010-10-03}}
*{{cite web|url=http://research.microsoft.com/en-us/um/people/gbell/Computer_Structures_Principles_and_Examples/csp0167.htm
|title=Computer Structures: Principles and Examples, Part 2, REGIONS OF COMPUTER SPACE, Section 1, MICROPROGRAM-BASED PROCESSORS, Seite 151 ff. |publisher=McGraw-Hill Computer Science Series |accessdate=2010-10-03}}
*{{cite web|url=http://www.intel.com/Assets/PDF/manual/253668.pdf |title=Intel(R) 64 and IA-32 Architectures Software Developer’s Manual, Volume 3A: System Programming Guide, Part 1, Chapter 9.11: "Microcode update facilities"|publisher=Intel Cooperation |date=December 2009 |accessdate=2010-10-03}}
*{{cite web|url=http://urbanmyth.org/microcode/ |title=Intel Microcode Update Utility for Linux|accessdate=2010-10-03}}
*{{cite web|url=http://support.microsoft.com/kb/936357 |title=A microcode reliability update is available that improves the reliability of systems that use Intel processors|Microsoft|accessdate=2010-10-03}}
*{{cite web|url=http://www.intel.com/support/motherboards/server/sb/cs-021619.htm| title=BIOS Update required when Missing Microcode message is seen during POST |publisher=Intel Cooperation |accessdate=2010-10-03}}

[[Kategorie:Rechnerarchitektur]]
[[Kategorie:Firmware]]
[[Kategorie:Assembler]]

[[en:Micro-operation]]

Mikroprogrammspeicher

2010-12-06T13:36:39Z

SimDoc: EN-Interwiki-Fix

Als '''Mikroprogrammspeicher''' wird ein [[Festwertspeicher]] oder flüchtiger Speicherbereich eines [[Prozessor (Hardware)|Prozessors]] bezeichnet, in dem das [[Mikroprogramm]] eines [[Mikroprogrammsteuerwerk]]s in Binärform als [[Mikrocode]] abgelegt ist.

== Aufbau ==
Im einfachsten Fall wird der Mikrocode aus ''n'' [[Mikrobefehl]]en der binären Wortlänge ''m'' gebildet, d. h., der Mikroprogrammspeicher umfasst genau ''n × m'' Bits. Der Mikrobefehlsspeicher wird üblicherweise nur zum Lesen der Mikrobefehle verwendet und kann als Festwertspeicher (ROM) ausgebildet sein. Zum Zweck der nachträglichen Optimierung des Mikrocodes ist es von Vorteil, den Mikroprogrammspeicher als flüchtigen Speicher auszulegen.
Dieser Speicherbereich dient dem Mikroprogrammsteuerwerk, um Mikrobefehle zum Steuern des Rechenwerks zu lesen. Die Zugriffsgeschwindigkeit ist an die Prozessorrechenleistung angepasst. Daher befinden sich der Mikroprogrammspeicher wie das Mikroprogrammsteuer- und Rechenwerk auf demselben Prozessor-Chip mit möglichst kurzer Anbindung.
Der Zugriff auf den Mikroprogrammspeicher erfolgt mikrobefehlsweise mit der Bitlänge ''m'', nicht notwendigerweise in vielfachen der Größe eines Bytes (8 bit). Demzufolge ist der Mikroprogrammspeicher in erster Linie als Bit- bzw. Mikrobefehlswort-adressierbarer Speicher aufzufassen.

Gängige Speichergrößen betragen zwischen 50 … 500 kBit, die Wortbreite eines Mikrobefehls zwischen ''m'' = 10  …100, der Mikroprogrammadressraum zwischen ''n'' = 3k … 24k. Die Größe des Mikrocodeadressraums richtet sich folglich danach, wie viele Mikrobefehle im Mittel benötigt werden, um einen Maschinenbefehl (OpCode) in Mikrobefehle zu überführen; die Wortbreite danach, wie komplex die simulatan ablaufende Mikroprogrammsteuerung ausgelegt ist.

Als typische Speichergrößen mikrocodeprogrammierbarer Großrechner der Jahre 1960 bis 1980 sind anzuführen:
* [[System/360|IBM 360]] (Modelle 30, 40, 50, 65): 8k × 50, 4k × 56, 2,75 × 88, 2,75k × 100
* [[System/370|IBM 370]] (Modelle 145, 155, 165, 125): 16k × 32, 8k × 72, 2,5k × 108, 20 k × 22
* [[Siemens 4004]] (Modell 45, 151): 4k × 56, 3k × 72
* [[PDP-11]] (Modelle 05, 40, 45, 70): 0,25k × 40, 0,25k × 56, 0,25k × 65, 0,25k × 65

Die Bedeutung des Mikroprogrammspeichers als Mikrocodespeicher zur Steuerung eines virtuellen [[Rechenwerk]]s wird auf didaktische Weise mit dem [[Mikrocodesimulator]] [[MikroSim]] erläutert. Die veranschlagte Größe des Mikroprogrammspeichers für 1024 Instruktionen mit je 49 bit beträgt hier 49 kBit (1k × 49 bit).

== Literatur ==
*R. Hoffmann: ''Rechnerentwurf: Rechenwerke, Mikroprogrammierung, RISC.'' 3. Auflage. Oldenbourg, München 1993, ISBN 978-3-486-22174-9 (insbesondere Kap. 5: Mikroprogrammierung).

== Weblinks ==
*{{cite web|url=http://www.mikrocodesimulator.de/ |title=Mikrocodesimulator MikroSim 2010 |publisher=0/1-SimWare |date= |accessdate=2010-11-30}}

[[Kategorie:Rechnerarchitektur]]
[[Kategorie:Firmware]]
[[Kategorie:Technische Informatik]]

[[en:Control store]]

Mikroprogrammspeicher

2010-12-06T13:35:09Z

SimDoc: EN-Interwiki

Mikrocodesimulator

2010-12-06T10:25:38Z

SimDoc: Kategorie-Bearbeitung

Ein '''Mikrocodesimulator''' ist ein Hilfsmittel zur [[Simulation]] mikrocodeprogrammierter Steuerabläufe eines [[Mikroprogrammsteuerwerk]]s. Mittels der Mikrocodesimulation können mikrocodeprogrammierte Schaltabläufe schrittweise nachvollzogen werden, bevor diese in ein Mikrocodeprogrammsteuerwerk integriert werden. Mit der Simulation des Mikrocodes ist in erster Linie die Erstellung eines [[Mikroprogramm]]s und eine Überprüfung bzw. Optimierung der mikroprogrammierten Steuerung eines Leit- und Rechenwerks verbunden, das als reelle Hardware noch nicht vorliegt und vorab nachgestellt wird.

Im Vergleich hierzu wird unter der [[Emulation]] eines Mikrocodes die ganzheitlich exakte Nachahmung einer reell existierenden Mikrocodesteuerung eines Rechenwerks unter bestmöglicher Performance verstanden. In den Jahren 1960 bis Mitte 1970 wurde mit der Emulation der Mikroprogramme Inkompatibilitäten in der Hardware ausgeglichen. Auf diese Weise wurde ermöglicht, Software für ältere Rechnerhardware auf Nachfolgemodelle zu portieren, ohne dass ein zum Mikroprogramm abgestimmtes Mikroprogrammsteuerwerk in Hardwareform tatsächlich vorliegen musste. Die begriffliche Trennung zwischen Simulation und Emulation von Mikrocode bzw. dem zugrundeliegenden Mikroprogramm ist fließend. Doch im Unterschied zur Emulation benötigt die Simulation neben dem eigentlichen Mikroprogramm bzw. Mikrocode lediglich eine Software, während mit der Emulation des Mikrocodes der Einsatz von reeller Hardware verbunden ist.

Des Weiteren werden Mikrocodesimulatoren als Lernmittel eingesetzt, um Schaltabläufe didaktisch zu visualisieren und zu erläutern. Die Anfänge der Mikrocodesimulation zu Ausbildungszwecken hat seinen Ursprung in dem englischsprachigen Raum. Bereits in den 1980ern und 1990ern sind Programme für die Mikrocodesimulation in der Ausbildung auf dem Gebiet der Rechnerarchitektur im universitären Umfeld entstanden. Die Simulatoren sind unter Anderem für [[Betriebssystem]]e wie [[Mac OS]] für [[Apple Macintosh]] Rechner und [[UNIX]] für Großrechnersystem geschrieben worden. Im deutschsprachigen Raum hat sich der Mikrocodesimulator [[MikroSim]] auf dem Betriebssystem [[Microsoft Windows]] etabliert.

== Literatur ==
* R. Hoffmann: ''Rechnerentwurf: Rechenwerke, Mikroprogrammierung, RISC'', 3. Auflage. Oldenbourg, München 1993, ISBN 978-3-486-22174-9 (insb. Kap. 5: Mikroprogrammierung, Seite 183,184)

== Weblinks ==
* {{cite web|url=http://www.mikrocodesimulator.de/ |title=Mikrocodesimulator MikroSim 2010 |publisher=0/1-SimWare |date= |accessdate=2010-12-01}}
* {{cite web|url=http://portal.acm.org/citation.cfm?id=141854 |title=Microcode simulator for Apple Macintosh |publisher=Roy Fuller, ACM SIGCSE Bulletin, Volume 24 Issue 4, Dec. 1992|date= |accessdate=2010-12-01}}
* {{cite web|url=http://portal.acm.org/citation.cfm?id=805062 |title=A microprogram simulator|publisher=Steve Young, DAC '71, Proceedings of the 8th Design Automation Workshop|date= |accessdate=2010-12-01}}

[[Kategorie:Virtualisierung]]
[[Kategorie:Lernsoftware]]
[[Kategorie:Rechnerarchitektur]]
[[Kategorie:Technische Informatik]]

Mikrocodesimulator

2010-12-04T15:31:34Z

SimDoc: Formulierung

Mikroprogrammspeicher

2010-12-02T20:20:41Z

SimDoc: Kategorie-Bearbeitung

Als '''Mikroprogrammspeicher''' wird ein Festwertspeicher oder flüchtiger Speicherbereich eines Prozessors bezeichnet, in dem das [[Mikroprogramm]] eines [[Mikroprogrammsteuerwerk]]s in Binärform als [[Mikrocode]] abgelegt ist. Im einfachsten Fall wird der Mikrocode aus ''n'' [[Mikrobefehl]]en der binären Wortlänge ''m'' gebildet, d.h. der Mikroprogrammspeicher umfasst genau ''n x m'' Bits. Der Mikrobefehlsspeicher wird üblicherweise nur zum Lesen der Mikrobefehle verwendet und kann als Festwertspeicher (ROM) ausgebildet sein. Zum Zweck der nachträglichen Optimierung des Mikrocodes ist es von Vorteil, den Mikroprogrammspeicher als flüchtigen Speicher auszulegen.
Dieser Speicherbereich dient dem Mikroprogrammsteuerwerk, um Mikrobefehle zum Steuern des Rechenwerks zu lesen. Die Zugriffsgeschwindigkeit ist an die Prozessorrechenleistung angepasst. Daher befinden sich der Mikroprogrammspeicher wie das Mikroprogrammsteuer- und Rechenwerk auf demselben Prozessor-Chip mit möglichst kurzer Anbindung.
Der Zugriff auf den Mikroprogrammspeicher erfolgt mikrobefehlsweise mit der Bitlänge ''m'', nicht notwendigerweise in vielfachen der Größe eines Bytes (8 Bit). Demzufolge ist der Mikroprogrammspeicher in erster Linie als Bit- bzw. Mikrobefehlswort-adressierbarer Speicher aufzufassen. 
Gängige Speichergrößen betragen zwischen 50 … 500 kBit, die Wortbreite eines Mikrobefehls zwischen ''m''=10 ... 100, der Mikroprogrammadressraum zwischen ''n''=3k … 24k. Die Größe des Mikrocodeadressraums richtet sich folglich danach, wieviele Mikrobefehle im Mittel benötigt werden, um einen Maschinenbefehl (OpCode) in Mikrobefehle zu überführen; die Wortbreite danach, wie komplex die simulatan ablaufende Mikroprogrammsteuerung ausgelegt ist. 

Als typische Speichergrößen mikrocodeprogrammierbarer Großrechner der Jahre 1960 bis 1980 sind anzuführen: 

* [[System/360|IBM 360]] (Modelle 30, 40, 50, 65): 8k x 50, 4k x 56, 2.75 x 88, 2.75k x 100
* [[System/370|IBM 370]] (Modelle 145, 155, 165, 125): 16k x 32, 8k x 72, 2.5k x 108, 20k x 22
* [[Siemens 4004]] (Modell 45, 151): 4k x 56, 3k x 72
* [[PDP-11]] (Modelle 05, 40, 45, 70): 0.25k x 40, 0.25k x 56, 0.25k x 65, 0.25k x 65

Die Bedeutung des Mikroprogrammspeichers als Mikrocodespeicher zur Steuerung eines virtuellen Rechenwerks wird auf didaktische Weise mit dem [[Mikrocodesimulator]] [[MikroSim]] erläutert. Die veranschlagte Größe des Mikroprogrammspeichers für 1024 Instruktionen mit je 49 Bit beträgt hier 49kBit (1k x 49 bit).

== Literatur ==
*R. Hoffmann: ''Rechnerentwurf: Rechenwerke, Mikroprogrammierung, RISC'', 3. Auflage. Oldenbourg, München 1993, ISBN 978-3-486-22174-9 (insbesondere Kap. 5: Mikroprogrammierung)
== Weblinks ==
*{{cite web|url=http://www.mikrocodesimulator.de/ |title=Mikrocodesimulator MikroSim 2010 |publisher=0/1-SimWare |date= |accessdate=2010-11-30}}

[[Kategorie:Rechnerarchitektur]]
[[Kategorie:Firmware]]
[[Kategorie:Technische Informatik]]

Mikroassembler

2010-12-02T20:19:31Z

SimDoc: Kategorie-Bearbeitung

Als '''Mikroassembler''' wird ein Hilfsmittel bezeichnet, welches in der Lage ist, aus lesbaren symbolhaften Schaltanweisungen eines [[Mikroprogramm]]s binären [[Mikrocode]] zu generieren. Die Vorgehensweise ist ähnlich einem [[Assembler]] für Maschinenspracheprogramm (auch Makroassembler), der aus lesbaren Makrodefinitionen und den [[Mnemonics]] eines [[Befehlssatz]]es ein Programm in [[Bytecode]] übersetzt und zusammenstellt.

Da die Erstellung fehlerfreien Mikrocodes Detailwissen des zu programmierenden [[Mikroprogrammsteuerwerk|Mikroprogrammsteuer-]] und [[Rechenwerk]]s benötigt, welches nicht immer frei verfügbar ist, werden Mikroassembler überwiegend bei der Herstellung mikroelektronisch programmierter Bauteile und der Programmierung derer [[Firmware]] eingesetzt, weniger zu privaten Zwecken. In der Lernsoftware [[Mikrocodesimulator]] [[MikroSim]] ist ein Mikroassembler in Form eines Mikrocode-Editors realisiert, der es gestattet, [[Mikrobefehl]]e menügesteuert auf einfache Weise als Mikrocode zusammenzustellen.

== Literatur ==
R. Hoffmann: ''Rechnerentwurf: Rechenwerke, Mikroprogrammierung, RISC', 3. Auflage. Oldenbourg, München 1993, ISBN 978-3-486-22174-9 (insbesondere Kap. 5: Mikroprogrammierung, S.182)

== Weblinks ==
*{{cite web|url=http://www.mikrocodesimulator.de/ |title=Mikrocodesimulator MikroSim 2010 |publisher=0/1-SimWare |date= |accessdate=2010-12-01}}

[[Kategorie:Assembler]]
[[Kategorie:Rechnerarchitektur]]
[[Kategorie:Firmware]]
[[Kategorie:Technische Informatik]]

Nanoprogramm

2010-12-02T20:18:30Z

SimDoc: Kategorie-Bearbeitung

Das '''Nanoprogramm''' ist ein Schaltalgorithmus, der bei einer zwei- oder mehrstufigen [[Mikroprogramm]]ausführung eines [[Mikroprogrammsteuerwerk]]s eingebunden wird. Der Schaltalgorithmus der Befehlsausführung wird durch den (überwiegend) horizontal codierten [[Mikrocode]] repräsentiert und kann als übergeordnetes Schaltungshauptprogramm des Mikroprogrammsteuerwerks verstanden werden. Bei einer (teilweise) vertikal codierten Befehlsausführung des Mikrocodes wird auf Schaltungsunterprogramme verwiesen, die im sogenannten [[Nanocode]] realisiert sind, und nachgelagert, horizontal codierte Mikroprogrammabläufe steuern (vertikale Verlagerung). 

Im einfachsten Fall wird das Nanoprogramm als Schaltalgorithmus in Form eines [[Schaltnetz]]es realisiert, welches in die Mikrocodeausführung eingebunden wird. Der Nanocode (binärcode des Nanobefehls) wird als Eingangsparameter zur Steuerung von [[Dekodierer]]n und [[Multiplexer]]n verwendet, um zugeordnete Teilschaltnetze für die Erzeugung der Steuersignale zu aktivieren. Letzten Endes wird bei der Ausführung des Nanoprogramms, eingebettet in das übergeordnete (überwiegend) horizontal codierte Mikroprogramm, eine Folge ausschließlich horizontal codierter Mikrobefehlswörter fester Steuerbitlänge erzeugt. Jedes einzelne Steuer-Bit wird als Pikobefehl aufgefasst, welches einer Steuerleitung zugeordnet ist und dessen binärer Zustand den Schaltvorgang entweder blockiert oder aktiviert.

== Literatur ==
*R. Hoffmann: ''Rechnerentwurf: Rechenwerke, Mikroprogrammierung, RISC'', 3. Auflage. Oldenbourg, München 1993, ISBN 978-3-486-22174-9 (insbesondere Kap. 5: Mikroprogrammierung, S.159-240)
*W. Oberschelp, G. Vossen: ''Rechneraufbau und Rechnerstrukturen'', 10. Auflage. Oldenbourg, München 2006, ISBN 978-3-486-57849-2
*H. Malz: ''Rechnerarchitektur'', 2. Auflage. Vieweg+Teubner, 2004, ISBN 978-3-528-13379-5
*Th. Beierlein, O. Hagenbruch: ''Taschenbuch Mikroprozessortechnik'', 3. Auflage, Hanser Verlag, 2004, ISBN 978-3-446-22072-0
*W. K. Giloi: ''Rechnerarchitektur'', 2. Auflage, Springer, 1993, ISBN 978-3-540-56355-6

[[Kategorie:Programmierbare Logik]]
[[Kategorie:Rechnerarchitektur]]
[[Kategorie:Firmware]]
[[Kategorie:Technische Informatik]]

Nanocode

2010-12-02T20:16:57Z

SimDoc: Kategorie-Bearbeitung

Als '''Nanocode''' wird der in den [[Mikrocode]] eingebundene Teilcode eines zwei- oder mehrstufig arbeitenden [[Mikroprogrammsteuerwerk]]s bezeichnet. Ein vollständig horizontal codierter [[Mikrobefehl]] enthält keine Nanobefehle, sondern ist gänzlich aus Steuerbits (sog. Pikobefehlen) zusammengesetzt. Der Nanocode wird mit der vertikalen oder diagonalen Mikrobefehlscodierung in Verbindung gebracht.

Die Verwendung des Nanocodes erlaubt die Kompression horizontal codierten Mikrocodes, indem auf Mikrobefehlsteile referenziert wird, die das [[Nanoprogramm]] bilden. Auf diese Weise kann die Wortlänge des Mikrobefehls verkürzt und die Mikrocodebelegung im [[Mikroprogrammspeicher]] effektiver ausgenutzt werden. Mit 8 Bit können beispielsweise 256 Steuerbefehle im Nanocode adressiert werden, die eine nachgeordnete horziontale Mikrocodeabarbeitung definierter Bitlänge im Sinne einer Unterprogrammabarbeitung ermöglicht. Der Nanocode wird vor der Ausführung durch Decodierschaltungen/Multiplexer interpretiert, in horizontalen Mikrocode mit entsprechender Bitlänge umgewandelt und dem Mikroprogrammsteuerwerk zugeführt.

Nanocode verarbeiten beispielsweise [[Mikroprozessor]]en vom Typ [[MC68000]].
== Literatur ==
*R. Hoffmann: ''Rechnerentwurf: Rechenwerke, Mikroprogrammierung, RISC'', 3. Auflage. Oldenbourg, München 1993, ISBN 978-3-486-22174-9 (insbesondere Kap. 5: Mikroprogrammierung, S.159-240)
*W. Oberschelp, G. Vossen: ''Rechneraufbau und Rechnerstrukturen'', 10. Auflage. Oldenbourg, München 2006, ISBN 978-3-486-57849-2
*H. Malz: ''Rechnerarchitektur'', 2. Auflage. Vieweg +Teubner, 2004, ISBN 978-3-528-13379-5
*Th. Beierlein, O. Hagenbruch: ''Taschenbuch Mikroprozessortechnik'', 3. Auflage, Hanser Verlag, 2004, ISBN 978-3-446-22072-0
*W. K. Giloi: ''Rechnerarchitektur'', 2. Auflage, Springer, 1993, ISBN 978-3-540-56355-6

[[Kategorie:Programmierbare Logik]]
[[Kategorie:Rechnerarchitektur]]
[[Kategorie:Firmware]]
[[Kategorie:Technische Informatik]]

Mikroprogrammsteuerwerk

2010-12-02T20:15:31Z

SimDoc: Kategorie-Bearbeitung

Ein '''Mikroprogrammsteuerwerk''' ist der Teil ''mikroprogrammierter'' [[Hauptprozessor|Prozessoren]], der die Ausführung eines [[Maschinencode|Befehls]] im Prozessor steuert. Das Steuerwerk enthält eine Menge von Mikroprogrammen, die jeweils aus einer Liste von Steuersignalen bestehen, die das Verhalten von Prozessorelementen – zum Beispiel der [[Arithmetisch-logische Einheit|ALU]] und den [[Register (Computer)|Registern]] – regeln. Bei manchen Prozessoren können die Mikroprogramme auch nachträglich mittels [[Mikrocodeprogrammierung]] geändert werden. Man könnte die Mikroprogramme auch als [[Firmware]] der CPU bezeichnen.

== Funktionsweise ==
[[Maschinencode]]s müssen in einem Prozessor mittels sogenannter [[Mikrobefehl]]e in Steuersignale für die einzelnen Funktionseinheiten umgesetzt werden. Unter Umständen müssen dazu mehrere aufeinander folgende Verarbeitungsschritte ausgelöst werden, um die Funktion des Maschinencodes in Form einer Mikrobefehlssequenz zu realisieren.

Nehmen wir als Beispiel den Befehl ''ADD A,B'' eines fiktiven Prozessors, der die Inhalte der Register A und B addieren und das Ergebnis in das Register A zurückschreiben soll. Es könnte folgender Steuerablauf im Prozessor ablaufen: 

# Die [[Arithmetisch-logische Einheit|ALU]] wird für eine Addition konfiguriert.
# Der Inhalt von Register A wird an den ersten Eingang der ALU angelegt.
# Der Inhalt von Register B wird an den zweiten Eingang der ALU angelegt.
# Nach dem Ablauf der Durchlaufzeit für das Auslesen der Register A und B, sowie die Ausführung der Addition in der ALU wird das Ergebnis in ein Zwischenregister abgelegt.
# Der Inhalt von Register A wird mit dem Wert aus dem Zwischenregister überschrieben.
# Der nächste Befehl wird aus dem Speicher gelesen.
Denkbar wäre, die Schritte 1, 2, 3 und 5, 6 in jeweils einem Zeitintervall zusammengefasst ablaufen zu lassen.

Um diesen Ablauf zu steuern ist es möglich, eine Logik aufzubauen, die direkt diese Steuerung vornimmt. Der Nachteil bei dieser „festen Verdrahtung“ der Befehle ist die Komplexität der notwendigen Logik und die geringe Flexibilität bei notwendigen Veränderungen.

Im Falle der [[Mikroprogrammierung]] wird eine solche Ablaufsteuerung über die in einem Speicher abgelegten [[Mikroprogramm]]e realisiert. Der Maschinencode aktiviert dabei jeweils eines der Mikroprogramme, das in mehreren Schritten dann jeweils alle notwendigen Steuersignale für die Funktionseinheiten erzeugt. Im einfachsten Falle ist das Mikroprogrammsteuerwerk aufgebaut aus einem Befehlsregister, das den gerade ausgeführten Maschinencode enthält, einem Zähler für die Mikroprogrammschritte und einem Speicher, der die einzelnen Schritte enthält. Das Befehlsregister und der Zähler zusammen ergeben dann die Adresse für den Mikroprogrammspeicher. Es sind aber auch komplexere Mikroprogrammsteuerwerke möglich, die Sprungbefehle und Verzweigungen ausführen können, um komplexere Befehle zu ermöglichen. Die Bedeutung eines Mikroprogrammsteuerwerks als Leitwerk für die Steuerung eines virtuellen Rechenwerks wird mit dem Mikrocodesimulator [[MikroSim]] auf didaktische Weise vermittelt.

== Entwicklung ==
Frühe Prozessoren waren typischerweise mit fest verdrahteter Logik aufgebaut, später wurden dann vermehrt Mikroprogrammsteuerwerke eingesetzt. Diese Entwicklung hat sich bei den [[Mainframe|Mainframe-Computern]], wie auch später bei den [[Mikroprozessor]]en abgespielt. Mit der Entwicklung zu immer höheren Taktfrequenzen und zu [[Reduced Instruction Set Computer|RISC]]-Prozessoren ging dann allerdings der Trend wieder zu fest verdrahteter Logik. Aktuelle Prozessoren verwenden oft eine Mischform, bei der häufig verwendete Befehle oder Befehlsteile mit fest verdrahteter Logik ausgeführt werden und komplexe, oder nicht so zeitkritische Befehle ganz oder teilweise mit Mikrocode.

Einige Prozessoren können ihre Mikroprogrammierung auch selbst dynamisch ändern, zum Beispiel um einen anderen [[Befehlssatz]] zu erlauben oder die Ausführung zu [[Optimierung|optimieren]]. In einigen Fällen kann ein Teil des fest in einem Prozessor verankerten Mikrocodes durch nachgeladenen Mikrocode ersetzt werden um Fehler im Prozessor zu kompensieren.

Mikroprogrammsteuerwerke sind eine Form von [[Speicherprogrammierbare Steuerung|speicherprogrammierbarer Steuerung]]. Ihr Einsatz ist nicht auf Prozessoren begrenzt.

== Literatur ==
*{{cite book | author= H.P. Gumm, M. Sommer | title=Einführung in die Informatik | publisher=Oldenbourg, 8. Auflage |year=2009 |isbn=978-3-486-58724-1}}
*{{cite book | author= K. Wüst| title=Mikroprozessortechnik: Grundlagen, Architekturen und Programmierung von Mikroprozessoren, Mikrocontrollern und Signalprozessoren | publisher=Vieweg+Teubner Verlag, 3. Auflage |year=2008 |isbn=978-3-834-80461-7}}
*{{cite book | author= H. Bähring| title=Mikrorechner-Technik, Band 1, Mikroprozessoren und Digitale Signalprozessoren | publisher=Springer, 3. Auflage |year=2002 |isbn=3-540-41648-x}}
*{{cite book | author= H. Bähring| title=Mikrorechner-Technik, Band 2, Busse, Speicher, Pheriperie und Mikrocontroller| publisher=Springer, 3. Auflage |year=2002 |isbn=3-540-43693-6}}
*{{cite book | author= Bringschulte, Ungerer| title=Mikrocontroller und Mikroprozessoren| publisher=Springer |year=2002 |isbn=3-540-43095-4}}
*{{cite book | author= R. Kelch| title=Rechnergrundlagen - Von der Binärlogik zum Schaltwerk| publisher=Fachbuchverlag Leipzig |year=2003 |isbn=3-446-22112-1}}
*{{cite book | author= R. Kelch| title=Rechnergrundlagen - Vom Rechenwerk zum Universalrechner| publisher=Fachbuchverlag Leipzig |year=2003 |isbn=3-446-22113-1}}
*{{cite book | author= Ch. Märtin| title=Einführung in die Rechnerarchitektur - Prozessoren und Systeme| publisher=Fachbuchverlag Leipzig |year=2003 |isbn=3-446-22242-1}}

== Weblinks ==
*{{cite web|url=http://www.mikrocodesimulator.de/ |title=Mikrocodesimulator MikroSim 2010 |publisher=0/1-SimWare |date= |accessdate=2010-10-03}}
*[http://daniel.netsniff-ng.org/microtowers/ Spiel Türme von Hanoi implementiert in einem Mikroprogrammsteuerwerk]



[[Kategorie:Rechnerarchitektur]]
[[Kategorie:Firmware]]
[[Kategorie:Technische Informatik]]

Mikrocode

2010-12-02T20:14:38Z

SimDoc: Kategorie-Bearbeitung

Der '''Mikrocode''' ist der [[Binärcode]] eines [[Mikrobefehl]]s oder einer Mikrobefehlssequenz eines [[Mikroprogramm]]s. Der Mikrocode kann als „[[Maschinensprache]]“ des [[Mikroprogrammsteuerwerk]]s zum Steuern des [[Rechenwerk]]s in einem [[Prozessor (Hardware)|Prozessor]] angesehen werden. Die Erzeugung von Mikrocode zur Steuerung einer virtuellen Recheneinheit wird mit dem Mikrocodesimulator [[MikroSim]] auf didaktische Weise vermittelt. In der Realität erlauben einige Prozessoren zum Zeitpunkt der [[Initialisierung]] das Überschreiben des bei der Fertigung festgelegten und in einem [[Festwertspeicher]] (Mikroprogrammspeicher) abgelegten Mikrocodes. Üblicherweise erfolgt dies durch Nachladen eines im EPROM-BIOS gespeicherten Mikrocodes. In diesem Fall bleibt der nachgeladene Mikrocode bis zum Abschalten des Prozessors erhalten, d. h. die [[Mikroprogrammierung]] ist reversibel. Ein Mikrocode-Update ist in aller Regel mit einem BIOS-Update verbunden.

== Literatur ==
*{{Literatur | Autor= H. P. Gumm, M.Sommer | Titel=Einführung in die Informatik | Verlag=Oldenbourg|Auflage=8.|Jahr=2009 |ISBN=978-3-486-58724-1}}
*{{Literatur | Autor= K. Wüst| Titel=Mikroprozessortechnik: Grundlagen, Architekturen und Programmierung von Mikroprozessoren, Mikrocontrollern und Signalprozessoren | Verlag=Vieweg+Teubner Verlag|Auflage=3.|Jahr=2008 |ISBN=978-3-834-80461-7}}
*{{Literatur | Autor= H. Bähring| Titel=Mikrorechner-Technik, Band 1, Mikroprozessoren und Digitale Signalprozessoren | Verlag=Springer|Auflage=3.|Jahr=2002 |ISBN=3-540-41648-x}}
*{{Literatur | Autor= H. Bähring| Titel=Mikrorechner-Technik, Band 2, Busse, Speicher, Peripherie und Mikrocontroller| Verlag=Springer|Auflage=3.|Jahr=2002 |ISBN=3-540-43693-6}}
*{{Literatur | Autor= Uwe Brinkschulte, Theo Ungerer| Titel=Mikrocontroller und Mikroprozessoren| Verlag=Springer |Jahr=2002 |ISBN=3-540-43095-4}}

== Weblinks ==
*{{cite web|url=http://www.mikrocodesimulator.de/ |title=Mikrocodesimulator MikroSim 2010 |publisher=0/1-SimWare |date= |accessdate=2010-10-03}}
*{{cite web|url=http://www.stéen.se/share/unix/kernel/microcode/microcode.pdf
|title=P6 Family Processor Microcode Update, Feature Review |publisher=J. Molina, W. Arbaugh |year=2000 |accessdate=2010-10-03}}
*{{cite web|url=http://www.cs.clemson.edu/~mark/uprog.html
|title=A Brief History of Microprogramming|publisher=M. Smotherman |year=2010 |accessdate=2010-10-03}}
*{{cite web|url=http://research.microsoft.com/en-us/um/people/gbell/Computer_Structures_Principles_and_Examples/csp0167.htm
|title=Computer Structures: Principles and Examples, Part 2, REGIONS OF COMPUTER SPACE, Section 1, MICROPROGRAM-BASED PROCESSORS, Seite 151 ff. |publisher=McGraw-Hill Computer Science Series |accessdate=2010-10-03}}
*{{cite web|url=http://www.intel.com/Assets/PDF/manual/253668.pdf |title=Intel(R) 64 and IA-32 Architectures Software Developer’s Manual, Volume 3A: System Programming Guide, Part 1, Chapter 9.11: "Microcode update facilities"|publisher=Intel Cooperation |date=December 2009 |accessdate=2010-10-03}}
*{{cite web|url=http://urbanmyth.org/microcode/ |title=Intel Microcode Update Utility for Linux|accessdate=2010-10-03}}
*{{cite web|url=http://support.microsoft.com/kb/936357 |title=A microcode reliability update is available that improves the reliability of systems that use Intel processors|Microsoft|accessdate=2010-10-03}}
*{{cite web|url=http://www.intel.com/support/motherboards/server/sb/cs-021619.htm| title=BIOS Update required when Missing Microcode message is seen during POST |publisher=Intel Cooperation |accessdate=2010-10-03}}

[[Kategorie:Programmierbare Logik]]
[[Kategorie:Rechnerarchitektur]]
[[Kategorie:Firmware]]
[[Kategorie:Technische Informatik]]

[[ca:Microcodi]]
[[en:Microcode]]
[[es:Microcódigo]]
[[nl:Microcode]]
[[simple:Microcode]]

Mikroprogrammierung

2010-12-02T20:11:26Z

SimDoc: Kategorie-Bearbeitung

Als '''Mikroprogrammierung''' wird die Methode und das Vorgehen verstanden Schalt-, Rechen- und Steuerabläufe in einem [[Rechenwerk]], insbesondere einem integrierten Rechenwerk ([[Mikrocontroller]], [[Mikroprozessor]]) unterhalb der Ausführungsebene von [[Maschinenbefehl]]en auf Mikrobefehlsebene festzulegen und zu regeln. Als Mikroprogrammierung kann die Erstellung eines Mikrobefehlssatzes als Abfolge von Mikrobefehlsequenzen in einer Art Steuersprache für Schalter verstanden werden. Vereinzelt wird durch den Begriff ''Mikrocode-Programmierung oder Mikrocodeprogrammierung'' die Erstellung des sogenannten [[Mikrocode]]s bei der Mikroprogrammierung betont, der die Binärform des Mikrobefehlssatzes darstellt.

Mit der Mikrocodeprogrammierbarkeit eines Rechenwerks ist das Vorhandensein eines dazu angepassten [[Mikroprogrammsteuerwerk]]s verbunden, welches durch die taktweise Abfolge der Mikrocodebefehlssequenz gesteuert wird. Die Möglichkeit einer flexibel programmierbaren Abfolgesteuerung von Mikrobefehlen setzt voraus, dass in jedem [[Mikrobefehl]] (engl. ''Micro Instruction'') selbst eine Berechnungsvorschrift zum Verweis, d. h. [[Adressierung (Datenverarbeitung)|Adressierung]], auf den nächsten anzusteuernden Mikrobefehl enthalten ist.

Üblicherweise ist ein Maschinensprachebefehlssatz eines [[Prozessor (Hardware)|Prozessors]] bei der Fertigung (z. B aus Kompatibilitätsgründen) vorgegeben und nicht veränderbar. Der den Maschinencode bildende Mikrobefehlssatz (kurz Mikrocode) ist in einem [[Festwertspeicher]] wie [[EPROM]] oder [[ROM]] inner- oder außerhalb des Rechenwerks untergebracht und wird ggf. bei der [[Initialisierung]] des Rechenwerks in das Mikroprogrammsteuerwerk geladen. Zur Optimierung von Schaltungsabläufen werden dennoch Möglichkeiten vorgesehen und Vorkehrungen getroffen, dass ein Mikrocode korrigiert, verbessert oder angepasst werden kann, um kostspielige Neuentwürfe im Sinne eines Mikrocode-[[Bugfix]] zu umgehen. In den Anfängen der Mikroprozessor-Ära war die Möglichkeit einer flexiblen Mikrocodeprogrammierung unumgänglich und gewünscht, um einzelne zu einem Baustein-Neuentwurf führende Implementierungsfehler zu verhindern. Mit den Fortschritten in der [[Verifikation]] und Integrierbarkeit digitaler Schaltungen schien der Aspekt der Umprogrammierbarkeit einige Zeit lang an Bedeutung zu verlieren.

Dennoch hat das Interesse an der Umprogrammierbarkeit im Laufe der letzten Jahre eine Wiederbelebung erfahren. So sind Mikroprozessoren der Firma Intel ab dem Modell Pentium Pro (P6) im Mikrocode umprogrammierbar. Der als [[FDIV-Bug]] bekannt gewordene Rechenfehler auf einem Teil der Intel Pentium-P5-Prozessoren konnte hingegen nicht durch Mikrocodeprogrammierung behoben werden sondern nur durch Prozessoraustausch. Mit der Mikrocodeprogrammierung ist die Möglichkeit gegeben, Rechensteuerwerke mittels Mikrocode-[[Update]]s für spezielle Betriebssysteme zu optimieren.

Das Vorgehen bei der Programmierung im Sinne der Zusammenstellung der Mikrobefehle zu einem Mikroprogramm wird im englischsprachigen Raum als ''Microcoding'' bezeichnet. Dabei werden Programmierwerkzeuge verwendet, die als Mikroassembler (engl. ''Microassembler'') bezeichnet werden. Mit diesen Hilfsmitteln ist es möglich, auf übersichtliche Weise Mikrobefehlssequenzen zu verwalten und diese in Binärcode zu übersetzen. Die Lernsoftware Mikrocodesimulator [[MikroSim]] vermittelt auf didaktische Weise die Bedeutung und das praktische Vorgehen bei der Mikroprogrammierung einer virtuellen Recheneinheit.

== Literatur ==
*{{cite book | author= H.P. Gumm, M. Sommer | title=Einführung in die Informatik | publisher=Oldenbourg, 8. Auflage |year=2009 |isbn=978-3-486-58724-1}}
*{{cite book | author= K. Wüst| title=Mikroprozessortechnik: Grundlagen, Architekturen und Programmierung von Mikroprozessoren, Mikrocontrollern und Signalprozessoren | publisher=Vieweg+Teubner Verlag, 3. Auflage |year=2008 |isbn=978-3-834-80461-7}}
*{{cite book | author= H. Bähring| title=Mikrorechner-Technik, Band 1, Mikroprozessoren und Digitale Signalprozessoren | publisher=Springer, 3. Auflage |year=2002 |isbn=3-540-41648-x}}
*{{cite book | author= H. Bähring| title=Mikrorechner-Technik, Band 2, Busse, Speicher, Peripherie und Mikrocontroller| publisher=Springer, 3. Auflage |year=2002 |isbn=3-540-43693-6}}
*{{cite book | author= Bringschulte, Ungerer| title=Mikrocontroller und Mikroprozessoren| publisher=Springer |year=2002 |isbn=3-540-43095-4}}

== Weblinks ==
*{{cite web|url=http://www.mikrocodesimulator.de/ |title=Mikrocodesimulator MikroSim 2010 |publisher=0/1-SimWare |date= |accessdate=2010-10-03}}
*{{cite web|url=http://www.stéen.se/share/unix/kernel/microcode/microcode.pdf
|title=P6 Family Processor Microcode Update, Feature Review |publisher=J. Molina, W. Arbaugh |year=2000 |accessdate=2010-10-03}}
*{{cite web|url=http://www.cs.clemson.edu/~mark/uprog.html
|title=A Brief History of Microprogramming|publisher=M. Smotherman |year=2010 |accessdate=2010-10-03}}
*{{cite web|url=http://research.microsoft.com/en-us/um/people/gbell/Computer_Structures_Principles_and_Examples/csp0167.htm
|title=Computer Structures: Principles and Examples, Part 2, REGIONS OF COMPUTER SPACE, Section 1, MICROPROGRAM-BASED PROCESSORS, Seite 151 ff. |publisher=McGraw-Hill Computer Science Series |accessdate=2010-10-03}}
*{{cite web|url=http://www.intel.com/Assets/PDF/manual/253668.pdf |title=Intel(R) 64 and IA-32 Architectures Software Developer’s Manual, Volume 3A: System Programming Guide, Part 1, Chapter 9.11: "Microcode update facilities"|publisher=Intel Cooperation |date=December 2009 |accessdate=2010-10-03}}
*{{cite web|url=http://urbanmyth.org/microcode/ |title=Intel Microcode Update Utility for Linux|accessdate=2010-10-03}}
*{{cite web|url=http://support.microsoft.com/kb/936357 |title=A microcode reliability update is available that improves the reliability of systems that use Intel processors|Microsoft|accessdate=2010-10-03}}
*{{cite web|url=http://www.intel.com/support/motherboards/server/sb/cs-021619.htm| title=BIOS Update required when Missing Microcode message is seen during POST |publisher=Intel Cooperation |accessdate=2010-10-03}}

[[Kategorie:Systemsoftware]]
[[Kategorie:Rechnerarchitektur]]
[[Kategorie:Firmware]]
[[Kategorie:Technische Informatik]]

[[fr:Microprogrammation]]
[[hr:Mikroprogramiranje]]
[[it:Microprogrammazione]]
[[sh:Mikroprogramiranje]]

Mikroprogramm

2010-12-02T20:10:22Z

SimDoc: Kategorie-Bearbeitung

Das '''Mikroprogramm''' ist der Algorithmus eines [[Mikroprogrammsteuerwerk]]s in einem [[Prozessor]] zum Steuern seines [[Rechenwerk]]s. Mikroprogramme werden mittels [[Mikroprogrammierung]] erstellt. Die Mikrobefehle eines Mikroprogramms werden in einer adressierbaren Reihenfolge angeordnet und in einem [[Festwertspeicher]], dem sog. [[Mikroprogrammspeicher]], bereitgestellt. Die Mikrobefehle enthalten in binärer Form codierte Anweisungen mit fester Bit-Anzahl zur Aktivierung und Deaktivierung logischer Funktionseinheiten. Auf diese Weise bestimmt das Mikroprogrammsteuerwerk mit Hilfe des Mikroprogramms, welche Schaltvorgänge in welcher Reihenfolge zur Umsetzung von Maschinenbefehlen für ein Rechenwerk benötigt werden. Die Gesamtheit aller im Mikroprogrammspeicher binär codierten Mikrobefehle bilden den [[Mikrocode]].

Zusätzlich enthalten die Mikrobefehle eine inhärent codierte Adressierungsvorschrift, mit deren Hilfe der nächste anzusteuernde Mikrobefehl zur taktweisen, zyklischen Abarbeitung des Steuerablaufplans berechnet werden kann. Auf diese Weise ist es möglich, Mikrobefehle im Mikroprogramm nicht nur in aufsteigender Adressreihenfolge mit einfacher Sprungweite auszuführen, sondern ebenso in Adressierungssequenzen, die absolute, relative und bedingte Adressierungssprünge beinhalten können. Somit besteht die Möglichkeit einer möglichst redundanzfreien Strukturierung des Ablaufplans bzgl. sich wiederholender Mikrobefehlssequenzen. Somit besteht die Möglichkeit den begrenzt vorhandenen Mikrobefehlsspeicher in einer CPU für die Programmierung von Maschinenbefehlen in der Steuersprache der Mikrobefehle möglichst effektiv zu nutzen.

Das Mikroprogramm kann unmittelbar in Form binär codierter Mikrobefehle erstellt werden. Aber auch Hilfsmittel wie Mikroassembler können zur Mikroprogrammierung herangezogen werden, um die Steueranweisungen der Mikrobefehle eines Mikrocodeprogramms aus einer lesbaren Darstellung in die unübersichtliche binäre Mikrobefehlsform automatisiert zu übersetzen. Gleichzeitig kann mit dem [[Mikroassembler]] der Mikroprogrammspeicherinhalt und die inhärent codierte Adressierungsreihenfolge einer programmierten Mikrobefehlssequenz flexibel verwaltet werden. Die Erstellung eines Mikroprogramms zur Steuerung einer virtuellen Recheneinheit wird mit dem Mikrocodesimulator [[MikroSim]] auf didaktische Weise vermittelt.

== Literatur ==
*{{cite book | author= H.P. Gumm, M. Sommer | title=Einführung in die Informatik | publisher=Oldenbourg, 8. Auflage |year=2009 |isbn=978-3-486-58724-1}}
*{{cite book | author= K. Wüst| title=Mikroprozessortechnik: Grundlagen, Architekturen und Programmierung von Mikroprozessoren, Mikrocontrollern und Signalprozessoren | publisher=Vieweg+Teubner Verlag, 3. Auflage |year=2008 |isbn=978-3-834-80461-7}}
*{{cite book | author= H. Bähring| title=Mikrorechner-Technik, Band 1, Mikroprozessoren und Digitale Signalprozessoren | publisher=Springer, 3. Auflage |year=2002 |isbn=3-540-41648-x}}
*{{cite book | author= H. Bähring| title=Mikrorechner-Technik, Band 2, Busse, Speicher, Peripherie und Mikrocontroller| publisher=Springer, 3. Auflage |year=2002 |isbn=3-540-43693-6}}
*{{cite book | author= Bringschulte, Ungerer| title=Mikrocontroller und Mikroprozessoren| publisher=Springer |year=2002 |isbn=3-540-43095-4}}

== Weblinks ==
*{{cite web|url=http://www.mikrocodesimulator.de/ |title=Mikrocodesimulator MikroSim 2010 |publisher=0/1-SimWare |date= |accessdate=2010-10-03}}
*{{cite web|url=http://www.stéen.se/share/unix/kernel/microcode/microcode.pdf
|title=P6 Family Processor Microcode Update, Feature Review |publisher=J. Molina, W. Arbaugh |year=2000 |accessdate=2010-10-03}}
*{{cite web|url=http://www.cs.clemson.edu/~mark/uprog.html
|title=A Brief History of Microprogramming|publisher=M. Smotherman |year=2010 |accessdate=2010-10-03}}
*{{cite web|url=http://research.microsoft.com/en-us/um/people/gbell/Computer_Structures_Principles_and_Examples/csp0167.htm
|title=Computer Structures: Principles and Examples, Part 2, REGIONS OF COMPUTER SPACE, Section 1, MICROPROGRAM-BASED PROCESSORS, Seite 151 ff. |publisher=McGraw-Hill Computer Science Series |accessdate=2010-10-03}}
*{{cite web|url=http://www.intel.com/Assets/PDF/manual/253668.pdf |title=Intel(R) 64 and IA-32 Architectures Software Developer’s Manual, Volume 3A: System Programming Guide, Part 1, Chapter 9.11: "Microcode update facilities"|publisher=Intel Cooperation |date=December 2009 |accessdate=2010-10-03}}
*{{cite web|url=http://urbanmyth.org/microcode/ |title=Intel Microcode Update Utility for Linux|accessdate=2010-10-03}}
*{{cite web|url=http://support.microsoft.com/kb/936357 |title=A microcode reliability update is available that improves the reliability of systems that use Intel processors|Microsoft|accessdate=2010-10-03}}
*{{cite web|url=http://www.intel.com/support/motherboards/server/sb/cs-021619.htm| title=BIOS Update required when Missing Microcode message is seen during POST |publisher=Intel Cooperation |accessdate=2010-10-03}}

[[Kategorie:Systemsoftware]]
[[Kategorie:Rechnerarchitektur]]
[[Kategorie:Firmware]]
[[Kategorie:Technische Informatik]]

[[bs:Mikroprogram]]
[[fr:Microprogrammation]]
[[hr:Mikroprogramiranje]]
[[it:Microprogrammazione]]
[[pl:Mikroprogram]]
[[sh:Mikroprogramiranje]]
[[sr:Микропрограм]]
[[sv:Mikroprogram]]
[[tr:Mikroprogramlama]]

MikroSim

2010-12-02T20:07:13Z

SimDoc: Kategorie-Erweiterung

Das Programm '''MikroSim''' ist eine [[Lernsoftware]] für das [[Betriebssystem]] [[Microsoft Windows]] zur hardware-unspezifischen Erläuterung der allgemeinen Funktionsweise und Steuerabläufe einer virtuellen Rechenmaschine. Es lassen sich in allgemein verständlicher Weise miniaturisierte [[Rechenwerk]]e didaktisch erläutern, die in [[Mikrocontroller]]n, [[Prozessor (Hardware)|Prozessoren]], und [[Computer]]n ablaufen.

== Allgemeines ==
Anfänglich wurde MikroSim als Prozessor-Simulationssoftware konzipiert. Da MikroSim allerdings die [[Mikroprogrammierung|Mikrocode-Programmierung]] eines [[Mikroprogrammsteuerwerk]]s mittels [[Mikrobefehl]]en in den Vordergrund stellt, betont die Anwendung primär die Mikrocodesimulation. In der gegenwärtigen Entwicklung erlangt der [[Simulator]] den Status einer virtuellen Applikation. Dabei werden allgemeine Prinzipien der System- und [[Rechnerarchitektur]] aufgegriffen, die sich mit dem Beginn des [[Informationszeitalter]]s etabliert haben und noch heute bestand haben, ohne sich auf spezielle Hardwareaspekte zu beschränken. Auf diese Weise erlangt das Simulationswerkzeug einen zeitlosen, freien didaktischen Nutzen, ohne sich auf spezielle vergangene und zukünftige Entwicklungen festzulegen. Die detaillierte Dokumentation und die zweisprachige Benutzerführung der [[E-Learning]]-Anwendung in Deutsch und Englisch, sowie die Auslegung der Software für die weithin verbreiteten Windows-Betriebssysteme, ist der Grund für den nachhaltigen Bestand der Software im Lehrbetrieb auf dem Gebiet der [[technische Informatik|technischen Informatik]] in Ausbildung und Lehre seit 1992.

== Entwicklungsgeschichte ==
Die Software basiert auf einer freien, unter [[Turbo-Pascal]] für das Betriebssystem [[MS-DOS]] geschriebenen Programmversion, die bis 1992 an der [[Philipps-Universität Marburg]] in der Vorlesung zur technischen Informatik für die Erläuterung von Mikrocodesteuerprozessen herangezogen wurde. Das bis dahin etablierte didaktische Vorlesungskonzept wurde im Sommer 1992 von Martin Perner während seines Physik-[[Diplom]]studiums (1990–1995) aufgegriffen und in freier Arbeit auf das Betriebssystem [[Microsoft Windows 3.x|Windows 3.1]] unter [[Visual Basic]] 1.0 portiert. Dabei entstand der Simulator in einer für damalige Verhältnisse völlig neuartigen Konzeption mit weitreichender Funktionalitätsverbesserung. Die Weiterentwicklung der Lehrsoftware unter Windows wurde bis 1995 von dem Fachbereich Mathematik/Informatik der Universität Marburg durch Heinz-Peter Gumm gefördert. Der Simulator wurde im November 1994 mit dem ''Europäischen Hochschul-Software-Preis 1994'' in der Kategorie [[Informatik]] in [[Heidelberg]] ausgezeichnet und im März 1995 auf der Computermesse [[CeBit]] in Hannover am Stand der hessischen Hochschulen der Öffentlichkeit vorgestellt.

Im Zeitraum Ende 1995 bis Anfang 2000 wurde der Simulator mit wenigen Verbesserungen unter der Revision MikroSim 1.2 veröffentlicht. In diesem Zeitraum wurde MikroSim im Rahmen des ''Europäischen Jahres des lebensbegleitenden Lernens 1996'' mit 1000 ECU prämiert, sowie beim Wettbewerb ''Multimedia Transfer'97'' im Rahmen der Messe ''LearnTec’97'' vorgestellt.<ref>[http://www.mikrocodesimulator.de/index.php#PreiseAuszeichnungen Preise und Auszeichnungen] auf der MikroSim-Website (Abgerufen am 5. November 2010.)</ref> In seiner vorletzten Neuauflage wurde der Simulator unter dem Namen „Mikrocodesimulator MikroSim2000“ mittels der Programmiersprache MS-Visual Basic 4.0 für [[Microsoft Windows 95|Windows 95]] angepasst.

Im Zeitraum Anfang 2008 bis 2009 erfuhr der Simulator weitreichende konzeptionelle Erweiterungen, ohne die Möglichkeiten der Mikrocodesimulation im Kern zu verändern. Dabei wird die Rechenleistung heutiger Windows-Applikationen und der verwendeten Hardware ausgenutzt, um Simulationen bis hin zur virtuellen Applikation zu ermöglichen. Seit Januar 2010 wird der Simulator unter „Mikrocodesimulator MikroSim 2010“ von 0/1-SimWare vertrieben.

== Kompatibilität ==
Die Software ist aus Kompatibilitätsgründen und zum Zweck einer möglichst weiten Verbreitung als 32-Bit-Version kompiliert und für [[Microsoft Windows XP|Windows XP]] optimiert worden. Das Programm kann auf allen 32- und 64-Bit-Betriebssystem der Versionen [[Microsoft Windows Vista| Windows Vista]] und [[Microsoft Windows 7|Windows 7]] ausgeführt werden. Auf spezielle XP-Kompatibilitätsmodi kann hierbei verzichtet werden.

== Lizenzierung und Bezug ==
Die MikroSim kann als frei verteilbare und kostenlose Demoversion mit Einschränkungen in der Funktionalität verwendet werden. Die Software-Limitierungen betreffen den Einsatz im Lehrbetrieb und können für die Dauer von 10 Tagen zu Testzwecke anonym freigeschaltet werden. 0/1-SimWare bietet zahlreiche Lizenzierungsmodelle an, um die Software sowohl als rechnergebundene Einzelplatzversion als auch als verteilbare, rechnerungebundene Vollversion einzusetzen. Die kostenpflichtige Vollversion richtet sich an Privat- und Einzelanwender, Gymnasien, Berufsschulen, Fachhochschulen und Universitäten für den Einsatz in Ausbildung und Lehre, die bereits von einigen deutschen Bildungsinstituten für den Einsatz in der Lehre lizenziert wurde. Die Lehrsoftware liegt unter ''www.mikrocodesimulator.de'' zum Download bereit.

== Funktionsweise und -umfang ==
Das Programm ermöglicht den schrittweisen Aufbau einer virtuellen Applikation, die in ihrer Funktionalität unveränderbar vorgegeben ist. Im Erkundungsmodus kann die Funktionsweise und Steuerungsmöglichkeit neu hinzugefügter Komponenten innerhalb eines Mikrocode-Befehlszyklus in Erfahrung gebracht werden. Die Breite der von MikroSim unterstützten Mikrobefehle umfasst 49 Bit. Ein Mikrobefehl wird in drei Teilphasen eines 3-Phasentakts abgearbeitet. Die Teilphasen werden als Hol-, Rechen- und Bringphase bezeichnet und bewirken das Holen eines 32 Bit breiten Registerwerts, das Ausführen einer 32-Bit-Berechnung, und das abschließende Speichern des Rechenergebnisses in einem CPU-internen [[Register (Computer)|Register]].

Im Simulationsmodus können hintereinander ausgeführte Mikrobefehle die zentrale Recheneinheit des Simulators steuern, wobei jeder Mikrobefehl auf die Adresse des nächsten Mikrobefehls verweist. Der Mikrobefehlssatz, gemeinhin als „Mikrocode“ der Recheneinheit bezeichnet, umfasst in der gegenwärtigen Implementierung von MikroSim 1024 49-Bit-lange Mikrobefehle. Strukturierungsmöglichkeiten im adressierbaren Ablaufplan im Mikrocode und die Entwicklung eines zyklisch arbeitenden, mikrocodeprogrammierten [[Interpreter]]s für Operationscodes (kurz [[Opcode]]s) ermöglichen die Implementierung von einzelnen mikrocodeprogrammierten Mikrobefehlssequenzen. Diese können als mikroprogrammierte [[Maschinenbefehl]]e aufgefasst werden. Der Mikrocode kann als [[Firmware]] für MikroSim als Mikrocode-[[Read-Only Memory|ROM]]-Datei (ROM, engl. {{lang|en|Read-Only Memory}}) abgelegt, modifiziert und erneut geladen werden.

Innerhalb eines Mikrobefehlzyklus kann sowohl die CPU als auch ein Ein-Ausgabe-Kontroller auf einen externen 16 kB umfassenden [[Random-Access Memory|RAM]]-[[Datenspeicher]] (RAM, engl. {{lang|en|Random-Access Memory}}) zurückgreifen. Über den Ein-Ausgabe-Kontroller erfolgt die Kommunikation mit angeschlossenen Ein- und Ausgabekomponenten mit [[Direct Memory Access|DMA]]-, [[I2C|I2C]]- und [[Interrupt Request|IRQ]]-Funktionalität. Unterstützt werden ein Ausgabe-Port, eine Anzeige, ein Zeitgeber, ein Ereignis-Trigger, ein Digital-Analog-Wandler, eine Tastatur und Daten-Ein-Ausgabe-Kanäle.

Der Mikrocodesimulator verwendet acht frei verwendbare 32-Bit-Register, deren Inhalt für vorzeichenbehaftete und vorzeichenlose Ganzzahlberechnungen, sowie für 32-Bit-Gleitkommaarithmetik eingesetzt werden. Mit einem übersichtlichen Systemzahleditor können die Registerinhalte betrachtet und modifiziert werden.

Die zentrale Recheneinheit des Simulators, die 32-Bit-[[Arithmetisch-logische Einheit|ALU]], unterstützt 128 verschiedene, grundlegende Rechenoperationen für Ganzzahlen und Interrupt-Steuerung bis hin zur [[Gleitkommaarithmetik]], die als erstes in vergleichbarer Weise bereits von [[Konrad Zuse]] eingeführt wurde. Zur Verdeutlichung dieser Arithmetik stehen elementare Rechenoperationen für die schrittweise auflösbare Gleitkomma-Registeroperationen in Mantisse und Exponent von den Grundberechnungen Addition/Subtraktion und Multiplikation/Division zur Verfügung. Weiterführend werden darauf aufbauend mächtigere 32-Bit-Rechenbefehle der Gleitkommaarithmetik in Mantisse und Exponent für die Grundrechenarten und elementarer analytischer Funktionen bereitgestellt, wie sie in mathematischen [[Coprozessor]]en realisiert sind. Dabei wird idealisiert angenommen, dass jede der 128 unterstützten ALU-Rechenoperationen für die Ausführung nur einen virtuellen Rechentakt benötigt.

Die Mikrobefehle können auf verschiedenen Simulationsniveaus ausgeführt werden:
* In dem niedrigsten Simulationsniveau unterstützt der Simulator die phasenweise Abarbeitung eines Mikrobefehls, der in eine sogenannte Hol-, Rechen- und Bring-Phase unterteilt ist. Die Abarbeitung der Teilphasen ist mit einer einstellbaren Verzögerung zur besseren Nachverfolgung möglich.
* Darauf aufbauend ist die komplette Abarbeitung eines Mikrobefehls in einem Dreiphasen-Takt ohne Verzögerung möglich. Ebenso die Abarbeitung mehrerer zu einem Maschinenbefehl zusammenfassbarer Mikrobefehle mittels eines in Mikrocode programmierten Maschinencodeinterpreters. Der Interpreter hat die Aufgabe, Maschinensprachebefehle, als Operationscodes in einem Byte-Wert codiert, aus dem RAM zu holen und an die entsprechende Mikrocodeunterprogrammadresse zur mikroprogrammierten Ausführung zu verzweigen.
* Darüber hinaus ist die Abarbeitung mehrerer Maschinenbefehle bis zu einem frei definierbaren Haltepunkt möglich. Dabei kann die Zeit bis zum Erreichen des Halte-Punkts für Simulationsoptimierungen gestoppt werden.
* Im höchsten Simulationsniveau kann der Mikrocodesimulator im Freilauf-Modus ohne jegliche Unterbrechung Maschinensprachesequenzen abarbeiten und somit die Interaktion der Applikation mit Ein- und Ausgabeschnittstellen in den Vordergrund rücken.

Mit verschiedenen Zusatzoptionen können visuelle CPU-Aktivitäten zu Gunsten der Steigerung der Abarbeitungsgeschwindigkeit unterdrückt werden, so dass die Maschinenprogrammierung der virtuellen Applikation in den Vordergrund tritt.
Mit dem Performance-Index-Monitor bietet der Simulator die Möglichkeit, die Abarbeitungsgeschwindigkeit und Ausführungsdauer entworfener Mikrobefehl-Sequenzen zu bestimmen und diese in Bezug zur Rechenleistung, gemessen in Gleitkommaoperationen pro Sekunde (FLOPS, engl. {{lang|en|[[Floating Point Operations Per Second]]}}) und [[Instruktionen pro Sekunde|Maschinen-/Mikrobefehle pro Sekunde]] (MIPs, engl. {{lang|en|Million Instructions per Second}}), der verwendeten Simulationshardware zu setzen.

Mit dem Zusatzprogramm MikroBAT, dem sogenannten „Basic Assembler Tool“ für MikroSim, können einfache Programme in [[Assembler (Informatik)|Assembler]] erstellt werden. Dabei wird der Befehlsumfang unterstützter [[Mnemonic]]s durch den Satz eigener mikrocodeprogrammierter Maschinenbefehle (Opcode) bestimmt. Das Zusatzprogramm ist in der Lage, das Assembler-Programm in Maschinencodes zu übersetzen und in den externen Datenspeicher für anschließende Simulationen zu übertragen.
Zusammen mit MikroBAT behandelt der Mikrocodesimulator in didaktisch aufbauender Weise Lehraspekte der technischen Informatik vom schaltergesteuerten Rechenautomaten bis zur Assembler programmierbaren Applikation.

== Literatur ==
* H.P.Gumm, M.Sommer: ''Einführung in die Informatik'', 8. Auflage. Oldenbourg, München 2009, ISBN 978-3-486-58724-1, (Zu MikroSim insbesondere Kap. 5.6, S.470-485.)

== Weblinks ==
* [http://www.mikrocodesimulator.de Mikrocodesimulator MikroSim] – Offizielle Website

== Einzelnachweise ==
<references />

[[Kategorie:Virtualisierung]]
[[Kategorie:Lernsoftware]]
[[Kategorie:Rechnerarchitektur]]
[[Kategorie:Assembler]]
[[Kategorie:Technische Informatik]]

Mikrocodesimulator

2010-12-02T08:28:54Z

SimDoc: hat „Benutzer:SimDoc/Mikrocodesimulator“ nach „Mikrocodesimulator“ verschoben: Veröffentlichung

Ein '''Mikrocodesimulator''' ist ein Hilfsmittel zur [[Simulation]] mikrocodeprogrammierter Steuerabläufe eines [[Mikroprogrammsteuerwerk]]s. Mittels der Mikrocodesimulation können mikrocodeprogrammierte Schaltabläufe schrittweise nachvollzogen werden, bevor diese in ein Mikrocodeprogrammsteuerwerk integriert werden. Mit der Simulation des Mikrocodes ist in erster Linie die Erstellung eines [[Mikroprogramm]]s und eine Überprüfung bzw. Optimierung der mikroprogrammierten Steuerung für eine Leit- und Rechenwerks verbunden, das als reelle Hardware noch nicht vorliegt und vorab nachgestellt wird.

Im Vergleich hierzu wird unter der [[Emulation]] eines Mikrocodes die ganzheitlich exakte Nachahmung einer reell existierenden Mikrocodesteuerung eines Rechenwerks unter bestmöglicher Performance verstanden. In den Jahren '60ern und '70ern wurde mit der Emulation der Mikroprogramme Inkompatibilitäten in der Hardware ausgeglichen. Auf diese Weise wurde ermöglicht, Software für ältere Rechnerhardware auf Nachfolgemodelle zu portieren, ohne dass ein zum Mikroprogramm abgestimmtes Mikroprogrammsteuerwerk in Hardwareform tatsächlich vorliegen musste. Die begriffliche Trennung zwischen Simulation und Emulation von Mikrocode bzw. dem zugrundeliegenden Mikroprogramm ist fließend. Doch im Unterschied zur Emulation benötigt die Simulation neben dem eigentlichen Mikroprogramm bzw. Mikrocode lediglich eine Software, während mit der Emulation des Mikrocodes der Einsatz von reeller Hardware verbunden ist.

Desweiteren werden Mikrocodesimulatoren als Lernmittel eingesetzt, um Schaltabläufe didaktisch zu visualisieren und zu erläutern. Die Anfänge der Mikrocodesimulation zu Ausbildungszwecken hat seinen Ursprung in dem englischsprachigen Raum. Bereits in den '80ern und '90ern sind Programme für die Mikrocodesimulation in der Ausbildung auf dem Gebiet der Rechnerarchitektur im universitären Umfeld entstanden. Die Simulatoren sind u.A. für [[Betriebssystem]]e wie [[Mac OS]] für [[Apple Macintosh]] Rechner und [[UNIX]] für Großrechnersystem geschrieben worden. Im deutschsprachigen Raum hat sich der Mikrocodesimulator [[MikroSim]] auf dem Betriebssystem [[Microsoft Windows]] etabliert.

== Literatur ==
*R. Hoffmann: ''Rechnerentwurf: Rechenwerke, Mikroprogrammierung, RISC'', 3. Auflage. Oldenbourg, München 1993, ISBN 978-3-486-22174-9 (insb. Kap. 5: Mikroprogrammierung, Seite 183,184)

== Weblinks ==
*{{cite web|url=http://www.mikrocodesimulator.de/ |title=Mikrocodesimulator MikroSim 2010 |publisher=0/1-SimWare |date= |accessdate=2010-12-01}}
*{{cite web|url=http://portal.acm.org/citation.cfm?id=141854 |title=Microcode simulator for Apple Macintosh |publisher=Roy Fuller, ACM SIGCSE Bulletin, Volume 24 Issue 4, Dec. 1992|date= |accessdate=2010-12-01}}
*{{cite web|url=http://portal.acm.org/citation.cfm?id=805062 |title=A microprogram simulator|publisher=Steve Young, DAC '71, Proceedings of the 8th Design Automation Workshop|date= |accessdate=2010-12-01}}

Mikroprogrammspeicher

2010-12-02T08:28:04Z

SimDoc: hat „Benutzer:SimDoc/Mikroprogrammspeicher“ nach „Mikroprogrammspeicher“ verschoben: Veröffentlichung

Mikroassembler

2010-12-02T08:26:52Z

SimDoc: hat „Benutzer:SimDoc/Mikroassembler“ nach „Mikroassembler“ verschoben: Veröffentlichung

Nanoprogramm

2010-12-02T08:25:59Z

SimDoc: hat „Benutzer:SimDoc/Nanoprogramm“ nach „Nanoprogramm“ verschoben: Veröffentlichung

Nanocode

2010-12-02T08:25:09Z

SimDoc: hat „Benutzer:SimDoc/Nanocode“ nach „Nanocode“ verschoben: Veröffentlichung

Mikrocodesimulator

2010-12-01T20:46:18Z

SimDoc: Emulation vs. Simulation

Ein '''Mikrocodesimulator''' ist ein Hilfsmittel zur [[Simulation]] mikrocodeprogrammierter Steuerabläufe eines [[Mikroprogrammsteuerwerk]]s. Mittels der Mikrocodesimulation können mikrocodeprogrammierte Schaltabläufe schrittweise nachvollzogen werden, bevor diese in ein Mikrocodeprogrammsteuerwerk integriert werden. Mit der Simulation des Mikrocodes ist in erster Linie die Erstellung eines [[Mikroprogramm]]s und eine Überprüfung bzw. Optimierung der mikroprogrammierten Steuerung für eine Leit- und Rechenwerks verbunden, das als reelle Hardware noch nicht vorliegt und vorab nachgestellt wird.

Im Vergleich hierzu wird unter der [[Emulation]] eines Mikrocodes die ganzheitlich exakte Nachahmung einer reell existierenden Mikrocodesteuerung eines Rechenwerks unter bestmöglicher Performance verstanden. In den Jahren '60ern und '70ern wurde mit der Emulation der Mikroprogramme Inkompatibilitäten in der Hardware ausgeglichen. Auf diese Weise wurde ermöglicht, Software für ältere Rechnerhardware auf Nachfolgemodelle zu portieren, ohne dass ein zum Mikroprogramm abgestimmtes Mikroprogrammsteuerwerk in Hardwareform tatsächlich vorliegen musste. Die begriffliche Trennung zwischen Simulation und Emulation von Mikrocode bzw. dem zugrundeliegenden Mikroprogramm ist fließend. Doch im Unterschied zur Emulation benötigt die Simulation neben dem eigentlichen Mikroprogramm bzw. Mikrocode lediglich eine Software, während mit der Emulation des Mikrocodes der Einsatz von reeller Hardware verbunden ist.

Desweiteren werden Mikrocodesimulatoren als Lernmittel eingesetzt, um Schaltabläufe didaktisch zu visualisieren und zu erläutern. Die Anfänge der Mikrocodesimulation zu Ausbildungszwecken hat seinen Ursprung in dem englischsprachigen Raum. Bereits in den '80ern und '90ern sind Programme für die Mikrocodesimulation in der Ausbildung auf dem Gebiet der Rechnerarchitektur im universitären Umfeld entstanden. Die Simulatoren sind u.A. für [[Betriebssystem]]e wie [[Mac OS]] für [[Apple Macintosh]] Rechner und [[UNIX]] für Großrechnersystem geschrieben worden. Im deutschsprachigen Raum hat sich der Mikrocodesimulator [[MikroSim]] auf dem Betriebssystem [[Microsoft Windows]] etabliert.

== Literatur ==
*R. Hoffmann: ''Rechnerentwurf: Rechenwerke, Mikroprogrammierung, RISC'', 3. Auflage. Oldenbourg, München 1993, ISBN 978-3-486-22174-9 (insb. Kap. 5: Mikroprogrammierung, Seite 183,184)

== Weblinks ==
*{{cite web|url=http://www.mikrocodesimulator.de/ |title=Mikrocodesimulator MikroSim 2010 |publisher=0/1-SimWare |date= |accessdate=2010-12-01}}
*{{cite web|url=http://portal.acm.org/citation.cfm?id=141854 |title=Microcode simulator for Apple Macintosh |publisher=Roy Fuller, ACM SIGCSE Bulletin, Volume 24 Issue 4, Dec. 1992|date= |accessdate=2010-12-01}}
*{{cite web|url=http://portal.acm.org/citation.cfm?id=805062 |title=A microprogram simulator|publisher=Steve Young, DAC '71, Proceedings of the 8th Design Automation Workshop|date= |accessdate=2010-12-01}}

Mikrocodesimulator

2010-12-01T15:22:36Z

SimDoc: Literatur

Ein '''Mikrocodesimulator''' ist ein Hilfsmittel zur [[Simulation]] mikrocodeprogrammierter Steuerabläufe eines [[Mikroprogrammsteuerwerk]]s. Mittels der Mikrocodesimulation können mikrocodeprogrammierte Schaltabläufe schrittweise nachvollzogen werden, bevor diese in ein Mikrocodeprogrammsteuerwerk integriert werden. Mit der Simulation des Mikrocodes ist in erster Linie die Erstellung eines [[Mikroprogramm]]s und eine Überprüfung der mikroprogrammierten Steuerung eines Leit- und Rechenwerks verbunden, das als reelle Hardware noch nicht vorliegt und vorab nachgestellt wird.

Im Vergleich hierzu wird unter der [[Emulation]] eines Mikrocodes die ganzheitlich exakte Erfassung einer reell existierenden Mikrocodesteuerung eines Rechenwerks verstanden. Auf diese Weise wird ermöglicht, Software für ältere Hardware auf moderne Rechner zu portieren, ohne dass ein Mikroprogrammsteuerwerk in Hardwareform tatsächlich vorliegen muss.

Darüberhinaus werden Mikrocodesimulatoren als Lernmittel eingesetzt, um Schaltabläufe didaktisch zu visualisieren und zu erläutern. Die Anfänge der Mikrocodesimulation zu Ausbildungszwecken hat seinen Ursprung in dem englischsprachigen Raum. Bereits in den '80ern und '90ern sind Programme für die Mikrocodesimulation in der Ausbildung auf dem Gebiet der Rechnerarchitektur im universitären Umfeld entstanden. Die Simulatoren sind u.A. für [[Betriebssystem]]e wie [[Mac OS]] für [[Apple Macintosh]] Rechner und [[UNIX]] für Großrechnersystem geschrieben worden. Im deutschsprachigen Raum hat sich der Mikrocodesimulator [[MikroSim]] auf dem Betriebssystem [[Microsoft Windows]] etabliert.

== Literatur ==
*R. Hoffmann: ''Rechnerentwurf: Rechenwerke, Mikroprogrammierung, RISC'', 3. Auflage. Oldenbourg, München 1993, ISBN 978-3-486-22174-9 (insb. Kap. 5: Mikroprogrammierung, Seite 183,184)

== Weblinks ==
*{{cite web|url=http://www.mikrocodesimulator.de/ |title=Mikrocodesimulator MikroSim 2010 |publisher=0/1-SimWare |date= |accessdate=2010-12-01}}
*{{cite web|url=http://portal.acm.org/citation.cfm?id=141854 |title=Microcode simulator for Apple Macintosh |publisher=Roy Fuller, ACM SIGCSE Bulletin, Volume 24 Issue 4, Dec. 1992|date= |accessdate=2010-12-01}}
*{{cite web|url=http://portal.acm.org/citation.cfm?id=805062 |title=A microprogram simulator|publisher=Steve Young, DAC '71, Proceedings of the 8th Design Automation Workshop|date= |accessdate=2010-12-01}}

Mikrocodesimulator

2010-12-01T15:11:33Z

SimDoc:

Ein '''Mikrocodesimulator''' ist ein Hilfsmittel zur [[Simulation]] mikrocodeprogrammierter Steuerabläufe eines [[Mikroprogrammsteuerwerk]]s. Mittels der Mikrocodesimulation können mikrocodeprogrammierte Schaltabläufe schrittweise nachvollzogen werden, bevor diese in ein Mikrocodeprogrammsteuerwerk integriert werden. Mit der Simulation des Mikrocodes ist in erster Linie die Erstellung eines [[Mikroprogramm]]s und eine Überprüfung der mikroprogrammierten Steuerung eines Leit- und Rechenwerks verbunden, das als reelle Hardware noch nicht vorliegt und vorab nachgestellt wird.

Im Vergleich hierzu wird unter der [[Emulation]] eines Mikrocodes die ganzheitlich exakte Erfassung einer reell existierenden Mikrocodesteuerung eines Rechenwerks verstanden. Auf diese Weise wird ermöglicht, Software für ältere Hardware auf moderne Rechner zu portieren, ohne dass ein Mikroprogrammsteuerwerk in Hardwareform tatsächlich vorliegen muss.

Darüberhinaus werden Mikrocodesimulatoren als Lernmittel eingesetzt, um Schaltabläufe didaktisch zu visualisieren und zu erläutern. Die Anfänge der Mikrocodesimulation zu Ausbildungszwecken hat seinen Ursprung in dem englischsprachigen Raum. Bereits in den '80ern und '90ern sind Programme für die Mikrocodesimulation in der Ausbildung auf dem Gebiet der Rechnerarchitektur im universitären Umfeld entstanden. Die Simulatoren sind u.A. für [[Betriebssystem]]e wie [[Mac OS]] für [[Apple Macintosh]] Rechner und [[UNIX]] für Großrechnersystem geschrieben worden. Im deutschsprachigen Raum hat sich der Mikrocodesimulator [[MikroSim]] auf dem Betriebssystem [[Microsoft Windows]] etabliert.

== Literatur ==
*R. Hoffmann: ''Rechnerentwurf: Rechenwerke, Mikroprogrammierung, RISC'', 3. Auflage. Oldenbourg, München 1993, ISBN 978-3-486-22174-9 (insb. Kap. 5: Mikroprogrammierung, Seite 183,184)

== Weblinks ==
*{{cite web|url=http://www.mikrocodesimulator.de/ |title=Mikrocodesimulator MikroSim 2010 |publisher=0/1-SimWare |date= |accessdate=2010-12-01}}
*{{cite web|url=http://portal.acm.org/citation.cfm?id=141854 |title=Microcode simulator for Apple Macintosh |publisher=Roy Fuller, ACM SIGCSE Bulletin, Volume 24 Issue 4, Dec. 1992|date= |accessdate=2010-12-01}}

Mikrocodesimulator

2010-12-01T13:09:28Z

SimDoc: Interlinksupdate

Mikrocodesimulator

2010-12-01T13:04:28Z

SimDoc: Interlinks

Mikroprogrammspeicher

2010-12-01T12:22:41Z

SimDoc: Links