<?xml version="1.0" encoding="UTF-8"?>
<!--This is a lesson file for Pauker (http://pauker.sourceforge.net)-->
<Lesson LessonFormat="1.7">
  <Description/>
  <Batch>
    <Card>
      <FrontSide Orientation="LTR" RepeatByTyping="false">
        <Text>Wie läuft ein Befehlszyklus ab?</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </FrontSide>
      <ReverseSide Orientation="LTR" RepeatByTyping="false">
        <Text>Am Anfang steht die Adresse des nächsten auszuführenden
Befehls im Befehlszählregister, die ins Speicheradreßregister
übertragen wird und von dort auf den Adreßbus gelangt. Damit wird
die entsprechende Zelle im Hauptspeicher angesprochen, deren
Inhalt über den Datenbus in das Speicherinhaltsregister der CPU
übertragen wird. Da es sich um einen Befehl handelt, wird dieser
ins Befehlsregister kopiert und dort decodiert und interpretiert.
Dazu sind meist weitere Speicherzugriffe notwendig (Abholen der
Befehlsoperanden).
[1801.KE1 S. 7f.]</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </ReverseSide>
    </Card>
    <Card>
      <FrontSide Orientation="LTR" RepeatByTyping="false">
        <Text>Welche Speicherarten gibt es allgemein?</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </FrontSide>
      <ReverseSide Orientation="LTR" RepeatByTyping="false">
        <Text>Hauptspeicher, Cache, Sekundärspeicher (Magnetplatten),
Tertiärspeicher (preiswerte, auswechselbare Medien wie z.B.
Disketten und CD-ROMs).
[1801.KE1 S. 6ff.]</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </ReverseSide>
    </Card>
    <Card>
      <FrontSide Orientation="LTR" RepeatByTyping="false">
        <Text>Wie funktioniert DMA?</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </FrontSide>
      <ReverseSide Orientation="LTR" RepeatByTyping="false">
        <Text>Voraussetzung sind das Vorhandensein eines DMA-Controllers,
der selbständig unter Umgehung der CPU über den Bus Daten in
den Hauptspeicher übertragen kann, sowie Gerätecontroller, die für
das DMA-Verfahren ausgelegt sind. Der Ablauf ist folgender: Der
Gerätetreiber teilt dem Controller die Nummer des zu lesenden
Blocks mit und dem DMA-Controller die Anfangsadresse des
Hauptspeicherbereichs, in den die Daten zu übertragen sind.
Jedesmal, wenn das nächste Wort im Register des Controllers
bereitsteht, sendet er über eine Anforderungsleitung ein Signal an
den DMA-Controller; dieser antwortet mit einem Signal über eine
Bestätigungsleitung (handshaking), übergibt auf dem Adreßbus die
Hauptspeicheradresse für das Datenwort und zählt die Adresse
weiter hoch. Nach Übertragung aller Datenwörter löst er eine
Unterbrechung der CPU aus.
[1801.KE1 S. 24]</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </ReverseSide>
    </Card>
    <Card>
      <FrontSide Orientation="LTR" RepeatByTyping="false">
        <Text>Was sind die Bestandteile eines Prozessors?</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </FrontSide>
      <ReverseSide Orientation="LTR" RepeatByTyping="false">
        <Text>Ein von-Neumann-Rechner (= Prozessor) besteht aus: 
Steuerwerk,
Operationswerk, 
Registersatz, 
Adresswerk, 
Systembus-Schnittstelle. 
Der Kurs 1801 beschränkt sich auf die Nennung von
Rechenwerk, 
Befehlszählregister (Programmzähler),
Speicheradressregister, 
Speicherinhaltsregister, 
Befehlsregister und
Akkumulator.
[1801.KE1 S. 6ff., ausführlich in 1707.KE7 S. 24f.]</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </ReverseSide>
    </Card>
    <Card>
      <FrontSide Orientation="LTR" RepeatByTyping="false">
        <Text>Wie ist die allgemeine Hardwarearchitektur eines
Computers?</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </FrontSide>
      <ReverseSide Orientation="LTR" RepeatByTyping="false">
        <Text>Die wesentlichen Bestandteile der Hardware sind: Prozessor
(CPU), Hauptspeicher (main memory) und die Ein-Ausgabegeräte
(I/O devices).
[1801.KE1 S. 6]</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </ReverseSide>
    </Card>
    <Card>
      <FrontSide Orientation="LTR" RepeatByTyping="false">
        <Text>Was sind virtuelle Geräte?</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </FrontSide>
      <ReverseSide Orientation="LTR" RepeatByTyping="false">
        <Text>Treiber, Controller und Gerät bilden als virtuelles Gerät eine
konzeptuelle Einheit; daran lassen sich die Konzepte der
Abstraktion, der Kapselung und des Schichtenmodells
demonstrieren.
[1801.KE1 S. 18]</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </ReverseSide>
    </Card>
    <Card>
      <FrontSide Orientation="LTR" RepeatByTyping="false">
        <Text>Mit welchem Datentyp kann der Hauptspeicher
beschrieben werden?</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </FrontSide>
      <ReverseSide Orientation="LTR" RepeatByTyping="false">
        <Text>Als Array von Wörtern.
[1801.KE1 S. 6]</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </ReverseSide>
    </Card>
    <Card>
      <FrontSide Orientation="LTR" RepeatByTyping="false">
        <Text>Was passiert beim Lesezugriff auf die Festplatte?</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </FrontSide>
      <ReverseSide Orientation="LTR" RepeatByTyping="false">
        <Text>Hier wird die Hardware-Sicht beschrieben (zur Software-Sicht
siehe Frage [147]): Zunächst wird der Schreib-/Lesekopf auf den
richtigen Zylinder positioniert; dann wird abgewartet, bis der
gesuchte Sektor am Kopf vorbeiläuft; dann wird der Sektor gelesen
und seine Daten werden in den Hauptspeicher übertragen. Die
Zugriffszeit setzt sich folglich zusammen aus Positionierungs-,
Latenz- und Übertragungszeit.
[1801.KE1 S. 11]</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </ReverseSide>
    </Card>
    <Card>
      <FrontSide Orientation="LTR" RepeatByTyping="false">
        <Text>Wie ist eine Festplatte aufgebaut?</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </FrontSide>
      <ReverseSide Orientation="LTR" RepeatByTyping="false">
        <Text>Aus einer oder mehreren magnetisierbar beschichteten Scheiben,
die synchron über eine Spindel angetrieben werden und sich (fast)
permanent mit gleicher Umdrehungszahl drehen. Auf jeder
Oberfläche gleitet ein Schreib-/Lesekopf, wobei alle Köpfe
synchron auf die so genannten Zylinder (= alle übereinander
liegenden Spuren aller Platten) positioniert werden. Jede der
mehreren tausend kreisförmigen Spuren pro Platte ist in mehrere
hundert Sektoren unterteilt; ein Sektor ist die kleinste Einheit, auf
die wahlfrei zugegriffen werden kann.
[1801.KE1 S. 10f.]</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </ReverseSide>
    </Card>
    <Card>
      <FrontSide Orientation="LTR" RepeatByTyping="false">
        <Text>Wie läuft so ein Interrupt genau ab?</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </FrontSide>
      <ReverseSide Orientation="LTR" RepeatByTyping="false">
        <Text>Nach vollständiger Beendigung des laufenden Befehls gibt der
Prozessor der Interruptanforderung statt, falls der Interrupt
zugelassen ist (NMI oder durch IE-Bit im Statusregister).
Anschließend wird der aktuelle Prozessorzustand gerettet und über
einen Interruptvektor die Startadresse einer Interruptroutine
ermittelt und diese gestartet.
[1801.KE1 S. 21, ausführlich in 1707.KE7 S. 41f., 44f.]</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </ReverseSide>
    </Card>
    <Card>
      <FrontSide Orientation="LTR" RepeatByTyping="false">
        <Text>Welche Interrupts gibt es?</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </FrontSide>
      <ReverseSide Orientation="LTR" RepeatByTyping="false">
        <Text>Hardware-Unterbrechungen und Software-Unterbrechungen.
[1801.KE1 S. 21ff.]</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </ReverseSide>
    </Card>
    <Card>
      <FrontSide Orientation="LTR" RepeatByTyping="false">
        <Text>Wie können Zugriffe auf die Festplatte optimiert
werden?</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </FrontSide>
      <ReverseSide Orientation="LTR" RepeatByTyping="false">
        <Text>Die drei üblichen Strategien sind:
FCFS (first-come-first-served) bearbeitet die Aufträge in der
Reihenfolge ihres Eingangs; diese Strategie ist am wenigsten
optimal.
SSTF (shortest-seek-time-first) bearbeitet jeweils denjenigen
Auftrag als nächsten, dessen Spur der momentanen Position des
Schreib-/Lesekopfes am nächsten liegt.
SCAN bewegt den Kopf abwechselnd von außen nach innen und
zurück über die gesamte Platte und führt dabei die Aufträge aus,
deren Spuren gerade überquert werden.
[1801.KE1 S. 12]</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </ReverseSide>
    </Card>
    <Card>
      <FrontSide Orientation="LTR" RepeatByTyping="false">
        <Text>Was haben Threads nicht gemeinsam?</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-16777216" Background="-1"/>
      </FrontSide>
      <ReverseSide Orientation="LTR" RepeatByTyping="false">
        <Text>Jeder Thread hat seine eigenen Registerinhalte, insbesondere
seinen eigenen Befehlszähler, und sein eigenes Stacksegment.
[1801.KE2 S. 63f.]
</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-16777216" Background="-1"/>
      </ReverseSide>
    </Card>
    <Card>
      <FrontSide Orientation="LTR" RepeatByTyping="false">
        <Text>Wie werden Prozesse generiert?</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-16777216" Background="-1"/>
      </FrontSide>
      <ReverseSide Orientation="LTR" RepeatByTyping="false">
        <Text>Das Betriebssystem stellt einen Prozessraum bereit, lädt das
angeforderte Programm, initialisiert Register und das
Stacksegment, setzt den Befehlszähler auf den Anfangswert und
macht den Prozess bereit. Im Kurs wird die C-Funktion fork
vorgestellt, die über einen Systemaufruf eine genaue Kopie des
aufrufenden Elternprozesses (einschließlich aller Registerinhalte,
Stack und Befehlszähler) erzeugt und bereit macht.
[1801.KE2 S. 59ff.]</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-16777216" Background="-1"/>
      </ReverseSide>
    </Card>
    <Card>
      <FrontSide Orientation="LTR" RepeatByTyping="false">
        <Text>Wie kann es zu einem deadlock kommen?</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </FrontSide>
      <ReverseSide Orientation="LTR" RepeatByTyping="false">
        <Text>Zum Beispiel durch die Benutzung mehrerer Semaphoren in der
falschen Reihenfolge: Angenommen, es gibt einen binären
Semaphor Z, der den Zugriff auf einen Puffer steuert, und zwei
Semaphoren F und B für bis zu n freie bzw. belegte Einträge in
diesem Puffer. Ferner sei Z.count = 1, F.count = 0 und B.count = n,
d.h. es gibt keine freien Einträge. Wenn nun ein einfügender
Prozess zuerst down(Z) ausführt, sperrt er damit den Zugriff für
jeden anderen Prozess; ein anschließendes down(F) läßt ihn
ebenfalls blockieren, da ja keine Einträge frei sind. Ein anderer
Prozess, der vielleicht up(F) ausführen könnte, damit der erste
Prozess wieder bereit werden kann, kommt aber nicht dazu, weil er
zuvor bei Abfrage von Z keinen Zugriff erhält. Damit sind sowohl
der erste Prozess als auch alle anderen Prozesse für immer
blockiert. Das nennt man Verklemmung oder deadlock. Die richtige
Reihenfolge, die keinen deadlock verursacht, wäre: (a) für
einfügende Prozesse: down(F), down(Z), Einfügen, up(Z), up(F);
(b) für entnehmende Prozesse: down(B), down(Z), Entnehmen,
up(Z), up(B).
[1801.KE2 S. 79f., 56f.]
</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </ReverseSide>
    </Card>
    <Card>
      <FrontSide Orientation="LTR" RepeatByTyping="false">
        <Text>Wie werden Prozesse generiert?</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </FrontSide>
      <ReverseSide Orientation="LTR" RepeatByTyping="false">
        <Text>Das Betriebssystem stellt einen Prozessraum bereit, lädt das
angeforderte Programm, initialisiert Register und das
Stacksegment, setzt den Befehlszähler auf den Anfangswert und
macht den Prozess bereit. Im Kurs wird die C-Funktion fork
vorgestellt, die über einen Systemaufruf eine genaue Kopie des
aufrufenden Elternprozesses (einschließlich aller Registerinhalte,
Stack und Befehlszähler) erzeugt und bereit macht.
[1801.KE2 S. 59ff.]</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </ReverseSide>
    </Card>
    <Card>
      <FrontSide Orientation="LTR" RepeatByTyping="false">
        <Text>Wenn in einem Multitaskingsystem ein Prozess vom
Prozessor ausgeführt wird, wie geht dass dann vonstatten, dass ein
anderer Prozess drankommt (wo doch der Prozessor vom einen
Prozess blockiert ist)?</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </FrontSide>
      <ReverseSide Orientation="LTR" RepeatByTyping="false">
        <Text>Der Timer erzeugt einen Interrupt, aufgrund dessen der Scheduler
des Betriebssystems den Prozessor erhält. Der Scheduler verwaltet
die bereiten Prozesse und übergibt an den, der an der Reihe ist.
</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </ReverseSide>
    </Card>
    <Card>
      <FrontSide Orientation="LTR" RepeatByTyping="false">
        <Text>Wie heißt der Teil des Betriebssystems, der für die
Umschaltung (von Prozessen) zuständig ist?</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </FrontSide>
      <ReverseSide Orientation="LTR" RepeatByTyping="false">
        <Text>Dispatcher.</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </ReverseSide>
    </Card>
    <Card>
      <FrontSide Orientation="LTR" RepeatByTyping="false">
        <Text>In welchen Fällen ist die Scheduling-Strategie shortestjob-
first sinnvoll?</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </FrontSide>
      <ReverseSide Orientation="LTR" RepeatByTyping="false">
        <Text>Im Batchbetrieb.
[1801, KE 1, S.30]</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </ReverseSide>
    </Card>
    <Card>
      <FrontSide Orientation="LTR" RepeatByTyping="false">
        <Text>Wie kann ein Prozess bei Round-Robin seine
Zeitscheibe vorzeitig freigeben?</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </FrontSide>
      <ReverseSide Orientation="LTR" RepeatByTyping="false">
        <Text>Durch Systemaufrufe.
[1801, KE 1, S.31]</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </ReverseSide>
    </Card>
    <Card>
      <FrontSide Orientation="LTR" RepeatByTyping="false">
        <Text>Nutzen denn beim Round-Robin alle Prozesse ihre
Zeitscheibe voll aus?</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </FrontSide>
      <ReverseSide Orientation="LTR" RepeatByTyping="false">
        <Text>Nein, durch das Auslösen von Interrupts kann ein Prozess seine
Zeitscheibe vorzeitig verlieren, bzw. zurückgeben (preemptive
Multitasking).</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </ReverseSide>
    </Card>
    <Card>
      <FrontSide Orientation="LTR" RepeatByTyping="false">
        <Text>Was passiert beim Lesezugriff auf die Festplatte?
(Softwaresicht)</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </FrontSide>
      <ReverseSide Orientation="LTR" RepeatByTyping="false">
        <Text>Hier wird die Software-Sicht beschrieben (zur Hardware-Sicht siehe Frage
[129]):
1. Eine Software-Unterbrechung wird ausgelöst, der Kontext des Prozesses
wird gerettet, der Ein-/Ausgabeteil des Betriebssystems wird gerufen.
2. Falls die Daten schon im Cache stehen, werden sie in den Adressraum
des Prozesses kopiert, der sofort wieder rechnend wird.
3. Anderenfalls wird der Prozess blockiert, der Leseauftrag wird in die
Warteschlange des Plattenlaufwerks geschrieben (= Auftrag an den
Gerätetreiber).
4. Sobald der Gerätetreiber rechnend wird, liest er den Auftrag aus der
Warteschlange, reserviert Speicherplatz und schickt einen Lesebefehl an den
Plattencontroller. Danach blockiert er.
5. Der Plattencontroller führt den Leseauftrag aus, überträgt (mit dem DMAController)
die Daten in den reservierten Bereich und löst eine
Unterbrechung aus.
6. Der Unterbrechungsvektor aktiviert die Unterbrechungsroutine für
Plattenzugriffe, die den Gerätetreiber wieder bereit macht und dann von der
Unterbrechung zurückkehrt.
7. Sobald der Gerätetreiber rechnend wird, entfernt er den Auftrag aus der
Warteschlange, informiert den Ein-/Ausgabeteil des Betriebssystems
(betroffener Prozess, Adresse des reservierten Speicherplatzes) und wird
wieder bereit.
8. Der Ein-/Ausgabeteil des Betriebssystems kopiert die Daten aus dem
Systemspeicher in den Adressraum des Prozesses, der wieder bereit wird.
9. Sobald der Prozess wieder rechnend wird, ist der Systemaufruf beendet.
[1801.KE1 S. 32]</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </ReverseSide>
    </Card>
    <Card>
      <FrontSide Orientation="LTR" RepeatByTyping="false">
        <Text>Wann ist Round-Robin bei der Scheduling Strategie
sinnvoll?</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </FrontSide>
      <ReverseSide Orientation="LTR" RepeatByTyping="false">
        <Text>Im Time-Sharing-Betrieb (Multitasking).</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </ReverseSide>
    </Card>
    <Card>
      <FrontSide Orientation="LTR" RepeatByTyping="false">
        <Text>Wie heißt die Datenstruktur, welche die Prozesse
verwaltet?</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </FrontSide>
      <ReverseSide Orientation="LTR" RepeatByTyping="false">
        <Text>Der Scheduler.</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </ReverseSide>
    </Card>
    <Card>
      <FrontSide Orientation="LTR" RepeatByTyping="false">
        <Text>Wie funktioniert die inode-Struktur?</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </FrontSide>
      <ReverseSide Orientation="LTR" RepeatByTyping="false">
        <Text>Die inode-Struktur ist eine Besonderheit von UNIX und seinen
Derivaten. Am Anfang eines inode stehen die Attribute der Datei,
gefolgt von den physischen Adressen der ersten 12 Blöcke und drei
weiteren Adressen, nämlich eines einfach-indirekten, eines
zweifachindirekten und eines dreifach-indirekten Index. Der
einfach-indirekte Index enthält bei einer Blockgröße von B bits und
einer Partitiongröße von b Blöcken B / log2 b Blockadressen. Der
zweifach-indirekte Index verweist auf ebenso viele Blöcke der
einfach-indirekten, der dreifach-indirekte Index auf ebenso viele
Blöcke der zweifach-indirekten Struktur.
[1801.KE2 S. 71f., 81]</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </ReverseSide>
    </Card>
    <Card>
      <FrontSide Orientation="LTR" RepeatByTyping="false">
        <Text>Wie funktioniert die FAT?</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </FrontSide>
      <ReverseSide Orientation="LTR" RepeatByTyping="false">
        <Text>Die FAT (file allocation table) ist eine Struktur, die von den
Betriebssystemen MS-DOS (einschließlich Windows) und OS/2
verwendet wird. Sämtliche Blöcke der Magnetplatte werden darin
verwaltet, wobei der Verzeichniseintrag einer Datei auf den ersten
Block der Datei verweist. In der FAT findet sich zu jedem Block die
Nummer des Folgeblocks bzw. ein Kenner für eof (end of file).
Sinnvollerweise wird zur Laufzeit eine Kopie der FAT im Cache des
Hauptspeichers gehalten.
[1801.KE2 S. 71f.]</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </ReverseSide>
    </Card>
    <Card>
      <FrontSide Orientation="LTR" RepeatByTyping="false">
        <Text>Wie wird der Speicher einer Festplatte verwaltet?</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </FrontSide>
      <ReverseSide Orientation="LTR" RepeatByTyping="false">
        <Text>Zur optimalen Nutzung des Platzes wurde die Forderung nach
zusammenhängender Speicherung aufgegeben. Stattdessen
wurden Speicherverfahren entwickelt, bei denen die Blöcke einzeln
gespeichert werden können, wo immer gerade Platz frei ist
(Stichworte FAT und inode).
[1801.KE2 S. 71]</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </ReverseSide>
    </Card>
    <Card>
      <FrontSide Orientation="LTR" RepeatByTyping="false">
        <Text>1): Wie wird der Hauptspeicher im Rechner
verwaltet?</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </FrontSide>
      <ReverseSide Orientation="LTR" RepeatByTyping="false">
        <Text>Nur das Betriebssystem hat direkten Zugriff auf den gesamten
physischen Adressraum; den Prozessen steht ein eigener
Adressraum zur Verfügung, der über logische Adressen
angesprochen wird (Stichworte: Basisregister, Grenzregister). Bei
konkurrierendem Zugriff auf den Hauptspeicher durch mehrere
Prozesse können bereite oder blockierte Prozesse in den
Externspeicher ausgelagert werden (swapping); beim erneuten
Einlagern kann der Prozess bei gleichem logischen einen anderen
physischen Adressraum zugeteilt bekommen. Beim paging wird der
Hauptspeicher in gleich große Bereiche (Seiten, pages) aufgeteilt,
jeder Prozess erhält die benötigte Anzahl von (nicht
notwendigerweise im Speicher zusammenhängenden) Seiten, und
die Umsetzung von logischen in physische Adressen erfolgt über
die Seitentabelle.
[1801.KE2 S. 47ff.]</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </ReverseSide>
    </Card>
    <Card>
      <FrontSide Orientation="LTR" RepeatByTyping="false">
        <Text>Was sind Dateien und wie werden sie realisiert?</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </FrontSide>
      <ReverseSide Orientation="LTR" RepeatByTyping="false">
        <Text>Eine Datei ist eine Folge von Datensätzen, die zusammengehörige
Information enthalten. Für den Benutzer wird die Datei durch ihren
Zugriffspfad und ihren Namen (filename) identifiziert.
[1801.KE2 S. 66]</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </ReverseSide>
    </Card>
    <Card>
      <FrontSide Orientation="LTR" RepeatByTyping="false">
        <Text>Nennen Sie typische Anwendungen für Threads!</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </FrontSide>
      <ReverseSide Orientation="LTR" RepeatByTyping="false">
        <Text>Typische Anwendungen für Threads sind:
• Parallelisierung von Programmen auf Mehrprozessorrechnern;
verschiedene Threads können jeweils einem eigenen Prozessor
zugewiesen werden.
• Gerätetreiber für langsame Geräte; der Prozessor im Controller
kann schon die nächste Anfrage bearbeiten, falls die vorherige
Anfrage noch im Zustand blockiert ist.
• Verteilte (Client-Server-)Systeme. Ein Server bietet seine
Dienste verschiedenen Clients an und nutzt dabei für jeden Client
einen Thread.
[1801.KE2 S. 80]</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </ReverseSide>
    </Card>
    <Card>
      <FrontSide Orientation="LTR" RepeatByTyping="false">
        <Text>Was ist zu beachten, wenn mehrere Threads
schreibend und lesend auf eine gemeinsame Datei zugreifen?</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </FrontSide>
      <ReverseSide Orientation="LTR" RepeatByTyping="false">
        <Text>Es gilt dasselbe wie bei Synchronisierung von Prozessen, vgl.
Frage [154].
[1801.KE2 S. 52f.]</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </ReverseSide>
    </Card>
    <Card>
      <FrontSide Orientation="LTR" RepeatByTyping="false">
        <Text>Was haben Threads nicht gemeinsam?</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </FrontSide>
      <ReverseSide Orientation="LTR" RepeatByTyping="false">
        <Text>Jeder Thread hat seine eigenen Registerinhalte, insbesondere
seinen eigenen Befehlszähler, und sein eigenes Stacksegment.
[1801.KE2 S. 63f.]</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </ReverseSide>
    </Card>
    <Card>
      <FrontSide Orientation="LTR" RepeatByTyping="false">
        <Text>Was sind Threads im Unterschied zu normalen
Prozessen?</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </FrontSide>
      <ReverseSide Orientation="LTR" RepeatByTyping="false">
        <Text>Mehrere Threads (leichtgewichtige Prozesse = LWPs) teilen sich
ein Programm, einen Adressraum (Codesegment, Datensegment)
und dieselben Dateien.
[1801.KE2 S. 63]
</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </ReverseSide>
    </Card>
    <Card>
      <FrontSide Orientation="LTR" RepeatByTyping="false">
        <Text>1): Welche Seite lagert man aus wenn ein Prozess mehr
Seitenrahmen benötigt als verfügbar?</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </FrontSide>
      <ReverseSide Orientation="LTR" RepeatByTyping="false">
        <Text>Es gibt verschiedene Strategien. Man kann zum Beispiel diejenige
Seite auslagern, deren Benutzung am weitesten zurückliegt (LRU =
least recently used).
[1801.KE2 S. 51]</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </ReverseSide>
    </Card>
    <Card>
      <FrontSide Orientation="LTR" RepeatByTyping="false">
        <Text>Was ist denn ein deadlock?</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </FrontSide>
      <ReverseSide Orientation="LTR" RepeatByTyping="false">
        <Text>Eine Verklemmung beim gemeinsamen Zugriff auf Ressourcen.
[1801.KE2 S. 79]</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </ReverseSide>
    </Card>
    <Card>
      <FrontSide Orientation="LTR" RepeatByTyping="false">
        <Text>2): Erklären Sie die auf Semaphoren definierten
Operationen up und down genauer!</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </FrontSide>
      <ReverseSide Orientation="LTR" RepeatByTyping="false">
        <Text>down: wenn count &gt; 0, dann dekrementiere count, anderenfalls
füge aufrufenden Prozess in W ein und blockiere ihn. up: wenn W
nicht leer, dann entferne den nächsten Prozess aus W und mache
ihn bereit, anderenfalls inkrementiere count. Ein Prozess ruft down
auf, wenn er ein Betriebsmittel benutzen will, und up, sobald er das
Betriebsmittel wieder freigibt.
[1801.KE2 S. 54]</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </ReverseSide>
    </Card>
    <Card>
      <FrontSide Orientation="LTR" RepeatByTyping="false">
        <Text>Welche Operationen sind auf einem Semaphor
definiert?</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </FrontSide>
      <ReverseSide Orientation="LTR" RepeatByTyping="false">
        <Text>down und up.
[1801. KE2 S. 54]</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </ReverseSide>
    </Card>
    <Card>
      <FrontSide Orientation="LTR" RepeatByTyping="false">
        <Text>Aus welchen Komponenten besteht ein
Semaphor?</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </FrontSide>
      <ReverseSide Orientation="LTR" RepeatByTyping="false">
        <Text>Aus einer Zählvariablen count (Anzahl freier Betriebsmittel) und
einer Prozessmenge W (Warteschlange). W ist leer, falls count&gt;0.
[1801.KE2 S. 54]</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </ReverseSide>
    </Card>
    <Card>
      <FrontSide Orientation="LTR" RepeatByTyping="false">
        <Text>Was ist ein Semaphor?</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </FrontSide>
      <ReverseSide Orientation="LTR" RepeatByTyping="false">
        <Text>Ein abstrakter Datentyp.
[1801.KE2 S. 54] (naja...)</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </ReverseSide>
    </Card>
    <Card>
      <FrontSide Orientation="LTR" RepeatByTyping="false">
        <Text>Welche Möglichkeiten der
Prozesssynchronisierung gibt es?</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </FrontSide>
      <ReverseSide Orientation="LTR" RepeatByTyping="false">
        <Text>(a) Schalter: schlecht, weil das ständige Abfragen unnötig CPUZeit
verbraucht, und weil Prozesse voneinander abhängig werden.
(b) Verwendung des von Dijkstra entwickelten Konzepts des
Semaphors.
(c) Monitore
[1801.KE2 S. 53f.]</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </ReverseSide>
    </Card>
    <Card>
      <FrontSide Orientation="LTR" RepeatByTyping="false">
        <Text>1): Wie kann man das Problem lösen das
entsteht wenn mehrere Prozesse gleichzeitig ablaufen?</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </FrontSide>
      <ReverseSide Orientation="LTR" RepeatByTyping="false">
        <Text>Durch Prozesssynchronisierung.
[1801.KE2 S. 53]</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </ReverseSide>
    </Card>
    <Card>
      <FrontSide Orientation="LTR" RepeatByTyping="false">
        <Text>Welches Problem gibt es, wenn mehrere Prozesse
gleichzeitig ablaufen?</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </FrontSide>
      <ReverseSide Orientation="LTR" RepeatByTyping="false">
        <Text>Wenn mehrere Prozesse auf dieselbe Ressource teils lesend, teils
schreibend zugreifen, liegen so genannte Wettkampfbedingungen
(race conditions) vor; welcher Prozess als erster das Ziel erreicht,
ist nicht vorhersehbar. Wenn kritische Abschnitte in den Prozessen
nicht gegen Unterbrechungen geschützt werden, ist der Inhalt der
Ressource (bzw. ihr Zustand) unbestimmt.
[1801.KE2 S. 52f.]
</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </ReverseSide>
    </Card>
    <Card>
      <FrontSide Orientation="LTR" RepeatByTyping="false">
        <Text>3): Wie nennt man das Verfahren, das die Idee nur gerade
benötigten Speicher im Hauptspeicher zu halten mit Paging
kombiniert?</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </FrontSide>
      <ReverseSide Orientation="LTR" RepeatByTyping="false">
        <Text>Virtueller Speicher (virtual memory).
[1801. KE2 S. 51]</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </ReverseSide>
    </Card>
    <Card>
      <FrontSide Orientation="LTR" RepeatByTyping="false">
        <Text>Was tut man, wenn ein Prozess mehr Seitenrahmen
benötigt als verfügbar sind?</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </FrontSide>
      <ReverseSide Orientation="LTR" RepeatByTyping="false">
        <Text>Dann muss eine andere Seite in den Sekundärspeicher
ausgelagert werden.
[1801.KE2 S. 51]</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </ReverseSide>
    </Card>
    <Card>
      <FrontSide Orientation="LTR" RepeatByTyping="false">
        <Text>Wie wird der logische auf den physischen
Speicher abgebildet?</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </FrontSide>
      <ReverseSide Orientation="LTR" RepeatByTyping="false">
        <Text>Zusammenhängende Adressräume: Der Inhalt des Basisregisters
wird zur logischen Adresse addiert. Wird der Inhalt des
Grenzregisters überschritten, liegt eine Verletzung des
Speicherschutzes vor.
Paging: Eine logische Adresse besteht aus einem höherwertigen
Teil, der als Index für die Seitentabelle benutzt wird, und einem
niederwertigen Teil, der relativen Adresse innerhalb der Seite.
Durch Austausch der höherwertigen Bits mit Hilfe der Seitentabelle
ergibt sich die physische Adresse.
[1801.KE2 S. 47ff.]</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </ReverseSide>
    </Card>
    <Card>
      <FrontSide Orientation="LTR" RepeatByTyping="false">
        <Text>Wie kommunizieren die Prozesse mit dem
Betriebssystem?</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </FrontSide>
      <ReverseSide Orientation="LTR" RepeatByTyping="false">
        <Text>Über die Programmierschnittstelle (Systemaufrufe).
[1801.KE1 S. 23, 33f.]</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </ReverseSide>
    </Card>
    <Card>
      <FrontSide Orientation="LTR" RepeatByTyping="false">
        <Text>Wie sollten die Zeitscheiben für round robin
gewählt werden? (Prozessorzuteilung)</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </FrontSide>
      <ReverseSide Orientation="LTR" RepeatByTyping="false">
        <Text>Wie effizient das Verfahren arbeitet, hängt von der Dicke der
Zeitscheiben ab; extreme Werte sind unzweckmäßig. Bei zu dicken
Zeitscheiben werden Ein-/Ausgabe-intensive Prozesse, die
frühzeitig blockieren und daher ihre Zeitscheibe nicht ausnutzen,
von rechenzeitintensiven Prozessen ausgebremst; bei zu dünnen
Zeitscheiben verbringt die CPU einen zu großen Teil ihrer Zeit mit
unproduktiven Kontextwechseln.
[1801.KE1 S. 30, 45]</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </ReverseSide>
    </Card>
    <Card>
      <FrontSide Orientation="LTR" RepeatByTyping="false">
        <Text>Welche Zuteilungsstrategien für den Prozessor sind für
interaktive Systeme geeignet?</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </FrontSide>
      <ReverseSide Orientation="LTR" RepeatByTyping="false">
        <Text>Interaktive Systeme, die mit vielen Benutzern gleichzeitig
kommunizieren, arbeiten im Time-Sharing-Betrieb; daher kommt
das Zeitscheiben-Verfahren in Frage.
[1801.KE1 S. 30]</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </ReverseSide>
    </Card>
    <Card>
      <FrontSide Orientation="LTR" RepeatByTyping="false">
        <Text>Welche Zuteilungsstrategien für den
Prozessor gibt es?</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </FrontSide>
      <ReverseSide Orientation="LTR" RepeatByTyping="false">
        <Text>FCFS (first-come-first-served) verwaltet eine FIFO-Warteschlange
und arbeitet sie ab. Das ist leicht zu implementieren, hat aber den
Nachteil, dass ein Prozess alle nachfolgenden blockieren kann,
wenn er sehr rechenintensiv ist. SJF (shortest job first) bearbeitet
die bereiten Prozesse in der Folge aufsteigenden Bedarfs an
Rechenzeit. Voraussetzung ist, dass sich der Rechenzeitbedarf aus
Erfahrungswerten gut vorhersagen lässt. Wenn das gegeben ist, ist
SJF sehr effizient. Im Time-Sharing-Betrieb wird einem bereiten
Prozess nur eine Zeitscheibe (time slice) an Rechenzeit zugeteilt
und bei Ablauf wieder entzogen, falls vorher keine Unterbrechung
eingetreten ist. Die Reihenfolge, in der die Zuteilung erfolgt, kann
durch eine ringförmige Warteschlange festgelegt werden (round
robin). Der Kontextwechsel wird vom Dispatcher durchgeführt.
[1801.KE1 S. 29f.]</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </ReverseSide>
    </Card>
    <Card>
      <FrontSide Orientation="LTR" RepeatByTyping="false">
        <Text>Wer teilt denn die CPU-Zeit den Prozessen zu?</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </FrontSide>
      <ReverseSide Orientation="LTR" RepeatByTyping="false">
        <Text>Welcher der bereiten Prozesse als nächster rechnen darf,
entscheidet der CPU-Scheduler.
[1801.KE1 S. 29]</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </ReverseSide>
    </Card>
    <Card>
      <FrontSide Orientation="LTR" RepeatByTyping="false">
        <Text>Wie funktionieren parallele Prozesse?</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </FrontSide>
      <ReverseSide Orientation="LTR" RepeatByTyping="false">
        <Text>Zu jedem beliebigen Zeitpunkt ist höchstens ein Prozess
rechnend; die Parallelität oder Gleichzeitigkeit ist also eine Illusion.
[1801.KE1 S. 30]</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </ReverseSide>
    </Card>
    <Card>
      <FrontSide Orientation="LTR" RepeatByTyping="false">
        <Text>1): Was für ein Problem gäbe es, wenn ein blockierter
Prozess direkt in den Zustand "rechnend" übergehen könnte?</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </FrontSide>
      <ReverseSide Orientation="LTR" RepeatByTyping="false">
        <Text>Die Fairneß bei der Zuteilung der CPU würde nicht beachtet.
[implizit in 1801.KE1 S. 29]</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </ReverseSide>
    </Card>
    <Card>
      <FrontSide Orientation="LTR" RepeatByTyping="false">
        <Text>Wie kann es zu Änderungen der Prozesszustände
kommen?</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </FrontSide>
      <ReverseSide Orientation="LTR" RepeatByTyping="false">
        <Text>Durch Interrupts, z.B. den Anstoß oder den Abschluß einer Ein-
/Ausgabeanforderung oder durch Unterbrechung des Schedulers
(Entzug der Zeitscheibe).
[1801.KE1 S. 28]</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </ReverseSide>
    </Card>
    <Card>
      <FrontSide Orientation="LTR" RepeatByTyping="false">
        <Text>Welche Zustände kann ein Prozess
durchlaufen?</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </FrontSide>
      <ReverseSide Orientation="LTR" RepeatByTyping="false">
        <Text>Erzeugt - bereit - rechnend - blockiert - beendet.
[Immer zeichnen! Man sollte vor allem darauf achten, dass alle
Pfeile korrekt eingezeichnet werden.]
[1801.KE1 S. 28 Abbildung 1.10]</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </ReverseSide>
    </Card>
    <Card>
      <FrontSide Orientation="LTR" RepeatByTyping="false">
        <Text>Worin liegt der Unterschied von Programmen und
Prozessen?</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </FrontSide>
      <ReverseSide Orientation="LTR" RepeatByTyping="false">
        <Text>Zum Prozess gehört auch noch der Prozesskontext, bestehend
aus den Registerinhalten (insbesondere Befehlszähler und
Grenzen des Adreßraums) sowie der Prozessnummer, im
Prozesskontrollblock (PCB) zusammengefaßt. Dort ist auch
vermerkt, ob der Prozess im System- oder Benutzermodus arbeitet,
und in welchem Zustand er sich befindet.
[1801.KE1 S. 28]
</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </ReverseSide>
    </Card>
    <Card>
      <FrontSide Orientation="LTR" RepeatByTyping="false">
        <Text>Wie nennt man ein laufendes Programm?</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </FrontSide>
      <ReverseSide Orientation="LTR" RepeatByTyping="false">
        <Text>Ein Programm, das sich gerade in Ausführung befindet, heißt
Prozess.
[1801.KE1 S. 28]</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </ReverseSide>
    </Card>
    <Card>
      <FrontSide Orientation="LTR" RepeatByTyping="false">
        <Text>Was ist ein Prozess?</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </FrontSide>
      <ReverseSide Orientation="LTR" RepeatByTyping="false">
        <Text>Ein Programm, das sich gerade in Ausführung befindet, heißt
Prozess.
[1801.KE1 S. 28]</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </ReverseSide>
    </Card>
    <Card>
      <FrontSide Orientation="LTR" RepeatByTyping="false">
        <Text>Was sind die Aufgaben eines
Betriebssystems?</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </FrontSide>
      <ReverseSide Orientation="LTR" RepeatByTyping="false">
        <Text>Das Betriebssystem bildet eine Schicht zwischen der
Rechnerhardware und den Benutzern und ihren
Anwendungsprogrammen. Es stellt zwei Schnittstellen zur
Verfügung, eine Benutzerschnittstelle und eine
Programmierschnittstelle, und kapselt damit die Zugriffe auf die
Hardware (Speicherverwaltung, Speicherschutz, Ein-
/Ausgabefunktionen). Außerdem koordiniert es die Prozesse
(Scheduling, Synchronisation).
[1801.KE1 S. 2, 29f.]</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </ReverseSide>
    </Card>
    <Card>
      <FrontSide Orientation="LTR" RepeatByTyping="false">
        <Text>1): Wie funktioniert die BS-Kommunikation mit Geräten?</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </FrontSide>
      <ReverseSide Orientation="LTR" RepeatByTyping="false">
        <Text>Die Geräte sind über Controller und einen Bus mit dem Prozessor
verbunden; das Betriebssystem kommuniziert über Gerätetreiber
mit den Controllern. Der Gerätetreiber verwendet entweder
spezielle Ein-/Ausgabebefehle des Betriebssystems und greift über
besondere Adressen auf die Controllerregister (data-out, data-in,
status, control) zu, oder diese Register sind als Teil des
Hauptspeichers realisiert (memory-mapped I/O).
[1801.KE1 S. 16f.]</Text>
        <Font Family="Dialog" Size="12" Bold="false" Italic="false" Foreground="-13421773" Background="-1"/>
      </ReverseSide>
    </Card>
  </Batch>
  <Batch/>
  <Batch/>
</Lesson>
