Übung Betriebssysteme - Übung 1 - Parallele und verteilte Systeme

> Übung Betriebssysteme
Übung 1
Aaron Scherzinger
Wintersemester 2012/13
Gruppe Parallele und Verteilte Systeme (PVS)
Institut für Informatik
Westfälische Wilhelms-Universität Münster
Organisatorisches
• Koordinator:
Michel Steuwer
Raum 705, Tel.: 83-32744
[email protected]
• Sprechstunde: nach Vereinbarung
• Informationen zur Vorlesung und Übung, Aufgabenblätter:
• Im Web: http://pvs.uni-muenster.de/pvs/lehre/WS12/bs
• Über Mailingliste [email protected]
• Anmeldung zur Mailingliste über
http://listserv.uni-muenster.de/mailman/listinfo/pvs-bs
• Übungstermin:
• Mittwochs 12.00 Uhr–14.00 Uhr, Hörsaal M4
• Auf den Folien steht viel aber nicht alles – Teilnahme an einer Übung
ist Voraussetzung zum Verständnis der Folien
Übung Betriebssysteme
WS 2012/13
Aaron Scherzinger
2
Prüfungsleistungen
• 90-minütige benotete Klausur
• Termin: 28.01.2013, 12–14 Uhr, M1
• Studiengänge:
• 1-Fach-Bachelor Informatik
• Diplom Informatik, Wirtschaftsinformatik, Geoinformatik,
Mathematik (Nebenfach Informatik)
• Lehramt Sek II (und Sek I) Informatik
• LA Gymn./Ges. Informatik
• Abtestat (unbenotet)
• Bearbeitung der Übungsblätter (mind. 50% der Punkte)
• Modul Systemstrukturen für 2-Fach-Bachelor Informatik
• Modul Systemstrukturen besteht aus den Veranstaltungen
Rechnerstrukturen und Betriebssysteme
• 4-stündige benotete Modulabschlussklausur (voraussichtlich am Ende
des Wintersemesters)
• Zur Zulassung zur Modulabschlussklausur muss entweder die Klausur
zu Rechnerstrukturen oder die Klausur zu Betriebssysteme (am 30. 01)
bestanden werden
Übung Betriebssysteme
WS 2012/13
Aaron Scherzinger
3
Übungsblätter
• Im Netz werden Übungsblätter zur selbständigen Bearbeitung
bereitgestellt
• Übungsblätter sollen praktische Kenntnisse vermitteln
• Intensive Beschäftigung mit den Übungsblättern ist Voraussetzung
zum Verständnis der Übung
• Übungsblätter werden korrigiert!
• Insbesondere: Inhalt der Übung ist klausurrelevant!
Übung Betriebssysteme
WS 2012/13
Aaron Scherzinger
4
Übungsblätter
• Prüfungsleistung:
• Schein, CP: Klausur
• Abtestat, unbenotet (GI): 50% der Übungspunkte oder Bestehen der
Klausur
• Jede mündliche Prüfung setzt das Bestehen der Klausur voraus!
• Bonuspunkte:
• Durch die erfolgreiche Bearbeitung der Übungen können bis zu 10% der
Klausurpunkte erworben werden.
• Bei weniger als 50% der möglichen Punkte für die Übungsaufgaben
werden keine Bonuspunkte vergeben.
• Ab 50% (1 Bonuspunkt) wird für weitere 5% der Übungspunkte je ein
Bonuspunkt vergeben.
• Bonuspunkte werden erst nach regulärem Bestehen der Klausur
angerechnet!
Übung Betriebssysteme
WS 2012/13
Aaron Scherzinger
5
Übungsblätter
• Voraussichtlich sieben Übungsblätter
• Bearbeitung
• In Gruppen von 3–4 Teilnehmern (nicht weniger!)
• Vorherige Anmeldung ist nicht nötig
• Zum Gründen von Gruppen kann die Mailingliste der Vorlesung genutzt
werden!
• Abgabe
• Hinweise auf den Aufgabenblättern beachten!!!
• Abgabe per E-Mail ([email protected])
• Namen und Matrikelnummern aller Teilnehmer angeben
• Termin i. d. R. Dienstag vor der Übung (genauer Termin auf dem
jeweiligem Blatt)
• Zur Bearbeitung der Übungsblätter ist eine gültige Nutzerkennung für
die Mathematik/Informatik CIP-Pools hilfreich!
Übung Betriebssysteme
WS 2012/13
Aaron Scherzinger
6
Ziel der Übungen
• Ziel der Übung ist . . .
• die Vertiefung der in der Vorlesung vorgestellten Konzepte
• die praktische Anwendung aus Sicht des (System-)Programmierers
• Inhalte der Übungsblätter:
• ca. 50 % Textaufgaben
• ca. 50 % Programmieraufgaben
• Für Programmieraufgaben werden die Programmiersprache C und
Unix/Linux verwendet
Übung Betriebssysteme
WS 2012/13
Aaron Scherzinger
7
Unix und C
Warum Unix?
• Betriebssystem 6→ Windows
• Es gibt einige Hundert BS die tatsächlich verwendet werden oder
wurden und mehrere Tausend (Forschungs-)Projekte
• Übersicht z. B.
http://en.wikipedia.org/wiki/List_of_operating_systems
• Unix Varianten (FreeBSD, OpenBSD, NetBSD, Linux, . . . ) für jede
gängige Hardware-Architektur kostenlos erhältlich
• Kostenlose Compiler, Editoren, Debugger, IDEs, . . .
• Im Source-Code verfügbar =⇒ Ideale Spielwiese ;-)
• Konzeptionell basieren alle gängigen Betriebssysteme auf Unix
• Man kann relativ einfach beobachten, was unter der Haube“ passiert
”
• Umfangreiche Literatur über Betriebssysteminterna
Übung Betriebssysteme
WS 2012/13
Aaron Scherzinger
8
Unix und C
Warum C?
• Relativ alte Sprache (erste Versionen ab 1971) aber immer noch eine
der wichtigsten überhaupt – die meisten Anwendungen werden in C
oder C++ entwickelt
• Sehr maschinennahe Sprache, deshalb gut für Systemprogrammierung
geeignet
• So gut wie alle gängigen Betriebssysteme sind in C/C++ geschrieben
• Systemnahe Programmierung i. d. R. ebenfalls nur in C
• C wurde für die Betriebssystemprogrammierung erdacht (für Unix)
Wer sich mit Betriebssystemen beschäftigt, kommt um C nicht
herum!
Übung Betriebssysteme
WS 2012/13
Aaron Scherzinger
9
C in der Übung
• In den ersten Übungen wird eine kurze Einführung in C geben
• Vorausgesetzte Vorkenntnisse: Java
• In der Übung kann nur eine fundamentale Einführung gegeben werden.
Eigenständige Übungen und Selbststudium sind notwendig!
• Standardwerk zu C:
Brian W. Kernighan, Dennis M. Ritchie
Programmieren in C
2. Ausgabe, Hanser Verlag, 1990
ISBN: 3-446-15492-3
• Weiter Links zu C und Linux/Unix auf den Webseiten unter
http://pvs.uni-muenster.de/pvs/lehre/c-doc.html
Übung Betriebssysteme
WS 2012/13
Aaron Scherzinger
10
Wiederholung von Grundlagen
Betriebssystem als . . .
• Virtuelle Maschine (Top-Down Sicht)
• Bietet abstrakte, einfache Sicht auf die Hardware
• Versteckt reale, low-level Eigenschaften
• Ressourcenmanager (Bottom-Up Sicht)
• Verwaltet Speicher, Platten, Terminals, . . .
• Koordiniert Zugriffe
• Fazit: Betriebssysteme müssen low-level Eigenschaften der Hardware
berücksichtigen um diese steuern zu können; BS-Entwickler benötigen
detaillierte Kenntnis der Hardware
• Im Folgenden werden kurz einige Grundlagen rekapituliert:
• Binärzahlen
• Prozessor und Speicher
• Compiler
Übung Betriebssysteme
WS 2012/13
Aaron Scherzinger
11
Binärzahlen
• Digitalrechner arbeiten mit Binärzahlen, deshalb hier eine kurze
Wiederholung
• Beispiel:
(123)10 = (1 · 102 + 2 · 101 + 3 · 100 )10 =
(1 · 26 + 1 · 25 + 1 · 24 + 1 · 23 + 0 · 22 + 1 · 21 + 1 · 20 )10 = (1111011)2
• Umwandlung durch Division mit Rest (umgekehrtes Hornerschema)
• Kompaktere Darstellung durch Oktal- und Hexadezimalzahlen.
• Oktal: drei Binärziffern ergeben eine Oktalziffer (23 = 8)
(001 100 101 011 111 110)2 = (145376)8
• Hexadezimal: vier Binärziffern ergeben eine Hexadezimalziffer
(24 = 16)
(1100 1010 1111 1110)2 = (CAFE)16
• Zwei Hexadezimalziffern ergeben ein Byte.
• Wegen der einfachen Umwandlung werden Binärziffern in Programmen
i. d. R. Oktal oder Hexadezimal angegeben.
Oft durch 0 für Oktal bzw. 0x für Hexadezimal gekennzeichnet, also
0145376 bzw. 0xCAFE
Übung Betriebssysteme
WS 2012/13
Aaron Scherzinger
12
Binärzahlen – wichtige
Eigenschaften
• Umrechnung zwischen 2er und 10er Potenzen:
• 210 = 1024 ≈ 1K (eigentlich 1 Ki (kibi) statt 1 K (kilo))
• 220 ≈ 1M
• 230 ≈ 1G
• 2n·10 ≈ 10n·3
• Vorsicht: 230 − 109 = 73.741.824
• Multiplikation/Division:
• 210 · 2 = 211
• 210 · 210 = 220
• 2m · 2n = 2m+n
• 2m /2n = 2m−n
• Binärziffern:
• Mit m Binärziffern können 2m verschiedene Zahlen dargestellt werden
• Mit m + n Binärziffern 2m+n verschiedene Zahlen
Übung Betriebssysteme
WS 2012/13
Aaron Scherzinger
13
Binärzahlen: Verknüpfungen
• Logische Operationen:
0 1
∨ (ODER) 0 1
¬ (NEG) 0
0 0 0
0 0 1
0 1
1 0 1
1 1 1
1 0
• Werden bei modernen Rechnern i. d. R. nur als Operationen auf
Maschinenworten (8, 16, 32 oder 64 Bit) angeboten, z. B.:
01101010 11010010
01101010 11010010
∧ 11111111 00000000
∨ 11111111 00000000
01101010 00000000
11111111 11010010
• Manipulation einzelner Bits:
∧
(UND)
• Setzen von Bit i in Wort x: x := x ∨ 2i
• Löschen von Bit i in Wort x: x := x ∧ ¬2i
Übung Betriebssysteme
WS 2012/13
Aaron Scherzinger
14
Prozessor und Speicher
• Grobstruktur eines einfachen Rechners:
• Prozessor:
Prozessor
• Rechenwerk (Arithmetic-LogicIR
Unit, ALU)
• Befehlsregister (Instruction Regi- AKKU
ster, IR)
ALU
• Befehlszähler (Instruction Pointer, IP)
• Stapelzeiger (Stack Pointer, SP)
I/O Gerät
Hauptspeicher
SP
0
Bus
IP
...
Befehle
Befehle
1
2
...
Befehle
Befehle
...
...
Daten
• Hauptspeicher:
Fortlaufend adressiert, enthält
Befehle und Daten
I/O Reg
n
I/O Reg
n+1
Daten
Daten
Daten
...
...
n−2
n−1
• I/O-Geräte:
Über I/O-Register gesteuert, werden über spezielle Speicheradressen
angesprochen
• Was sind Register?
Übung Betriebssysteme
WS 2012/13
Aaron Scherzinger
15
Programmausführung
1
Laden des nächsten Befehls von der im Befehlszähler angegebenen
Speicherstelle in das Befehlsregister
2
Erhöhen des Befehlszählers um eins (bzw. die Größe des geladenen
Befehls)
Dekodieren des Befehls
3
5
Ggf. Laden weiterer Operanden aus dem Speicher
Berechnung des Ergebnisses
6
Speicherung des Ergebnisses (z. B. in einem Register (Akku))
4
• Sprungbefehle: Manipulation des Befehlszählers (Laden der Zieladresse)
• Wichtig: Befehle und Daten liegen in einem fortlaufend und
zusammenhängend adressierten Speicher
Übung Betriebssysteme
WS 2012/13
Aaron Scherzinger
16
Stack (Stapel, Keller)
• LIFO Puffer, das zuletzt abgelegte Element (push Befehl) muss auch
als erstes wieder gelesen werden (pop Befehl)
• Extrem wichtiges, gleichzeitig einfach zu realisierendes Konzept, wird
i. d. R. durch HW als Maschinenbefehle bereitgestellt:
• push Befehl:
1 Schreiben des Parameters an die Speicherstelle SP
2 Erhöhen von SP um 1
• pop Befehl:
1 Verringern von SP um 1
2 Lesen des Wertes von Speicherstelle SP
• Wichtige Verwendungsmöglichkeit: Speichern von temporären Daten,
insb. Sprungadressen und lokalen Variablen bei Funktionen
Übung Betriebssysteme
WS 2012/13
Aaron Scherzinger
17
Compiler
• Hochsprachen sind sehr abstrakt und dadurch einfach zu gebrauchen.
• Werden durch Compiler in Maschinensprache übersetzt (oder von
einem anderen Programm interpretiert – hier nicht weiter betrachtet)
• Für HW-nahe Programmierung (von BS) ist ein grobes Verständnis
des Zusammenhangs mit dem Maschinencode wichtig
• Wie werden die folgenden Konzepte im Maschinencode realisiert:
• Variablen
• Datentypen
• Funktionen/Prozeduren
Übung Betriebssysteme
WS 2012/13
Aaron Scherzinger
18
Variablen
• Inhalt von Variablen liegt im Speicher
• Während der Übersetzung verwaltet der Compiler intern eine Tabelle
mit den Speicheradressen der Variablen
• Im ausführbaren Maschinenprogramm gibt es keine Variablen mehr!
Beispiel
int a = 0;
int b = 1;
int result;
result = a+b;
movl
$0, −4(%ebp)
movl
$1, −8(%ebp)
movl
−8(%ebp), %eax
/∗ b laden ∗/
addl
−4(%ebp), %eax
movl
%eax, −12(%ebp)
($ – Konstanten,
/∗ a ∗/
/∗ b ∗/
/∗ a+b ∗/
/∗ result ∗/
% – Register, %ebp – Basisadresse, x(%y) – Adresse %y+x)
Übung Betriebssysteme
WS 2012/13
Aaron Scherzinger
19
Datentypen: Programmiersprache
In Programmiersprachen sind meist Daten (Variablen) typisiert
• Variablen dürfen nur Werte ihres Typs zugewiesen werden,
z. B. int – ganzzahlige Werte
• Anweisungen/Befehle ergeben sich aus Datentypen,
z. B. + ist Addition für int und Konkatenation für String in Java
• Konvertierung: Um Daten verschiedenen Typs zu kombinieren müssen
diese umgewandelt werden (casts), implizit (z. B. int nach float) oder
explizit
• Korrektheit: Korrekte Typisierung wird vom Compiler/Laufzeitsystem
überwacht, z. B. keine Division /“ für String
”
Übung Betriebssysteme
WS 2012/13
Aaron Scherzinger
20
Datentypen: Maschinensprache
In Maschinensprache sind meist Befehle typisiert (wenn überhaupt)
• Beispiel Intel IA-32 (i386) Multiplikation:
mul
– unsigned int,
imul
– signed int,
fmul
– floating point
• Daten im Speicher sind untypisierte Bitfolgen,
man kann z. B. mul auf einen String anwenden
• Konvertierung: Maschinenbefehle um von einer Darstellung in eine
andere umzuwandeln (float/integer) müssen explizit im Programm
stehen
• Korrektheit: Keinerlei Überprüfung auf korrekte Typisierung!
⇒ Auch Datentypen sind im Maschinenprogramm nicht mehr (so wie in
einer Hochsprache) vorhanden
Übung Betriebssysteme
WS 2012/13
Aaron Scherzinger
21
Funktionsaufruf
• Funktionsaufrufe sind abstrakte Konstrukte (der Prozessor kennt keine
Funktionen!)
Hauptspeicher
• Funktion liegt als Maschinencode im Speicher
• Funktionsaufruf: Sprung an Anfangsadresse der
Funktion
funktion1
main
• Funktionsende: Rücksprung zur Stelle des Aufrufs
funktion3
• Dazu muss die Rücksprungadresse beim Aufruf
funktion2
gespeichert werden
• Rücksprungadressen werden auf einem Stapel abgelegt
• Funktionen müssen in der umgekehrten Reihenfolge ihres Aufrufs
beendet werden
=⇒ Die zuletzt abgelegte Adresse wird als erstes benötigt
• Entspricht LIFO-Eigenschaft des Stapels
Übung Betriebssysteme
WS 2012/13
Aaron Scherzinger
22
Funktionsaufruf: Beispiel
10816
Hauptspeicher
10000
...
10815
funktion3()
...
10816
11756
11757
...
24711
funktion1()
...
25042
Stapel
Befehlszähler
...
20000
25043
funktion2()
...
31732
...
...
funktion3()
24712
...
return
31732
11757
main
24712
...
funktion2()
10816
24712
...
return
41809
funktion3
funktion2()
...
41809
24712
...
10000
funktion2()
...
20000
24712
funktion1
funktion1()
25043
...
24712
...
11757
return
...
funktion2
24712
Übung Betriebssysteme
WS 2012/13
41809
Aaron Scherzinger
25043
return
23
Funktionsaufruf: Parameter und
Variablen
• Funktionsaufruf: Außer der Sicherung der Rücksprungadresse muss
folgendes beachtet werden:
• Übergabe von Parametern
• Sichern von Registerinhalten die innerhalb der Funktion überschrieben
werden
• Speicher für lokale Variablen reservieren
• Funktionsende:
• Freigeben lokaler Variablen
• Registerinhalte wiederherstellen
• Rückgabe des Ergebnisses
• Auch hier dient der Stapel zum Ablegen aller Daten
• Details sind Hardware- und Compiler-abhängig
Übung Betriebssysteme
WS 2012/13
Aaron Scherzinger
24
Beispiel: C-Funktionsaufruf bei
GCC/i386
foo:
/∗ Vorspann ∗/
pushl
%ebp
movl
%esp, %ebp
subl
$4, %esp
movl
$0, −4(%ebp)
/∗ Rumpf ∗/
movl
12(%ebp), %eax
addl
8(%ebp), %eax
movl
%eax, −4(%ebp)
/∗ Nachspann ∗/
movl
−4(%ebp), %eax
leave
ret
int foo(int a, int b) {
int c = 0;
c = a + b;
return c;
}
int main(int argc,
char ∗∗argv) {
int x;
x = foo(1, 2);
return 0;
}
/∗ Aufruf
pushl
pushl
call
in main ∗/
$2
$1
foo
Nicht Klausurrelevant ;-)
Übung Betriebssysteme
WS 2012/13
Aaron Scherzinger
25
C-Programmierung unter
Linux/Unix – Überblick
Editor
program.c
program.h
Compiler
program.o
otherprog.o
Linker
program
Übung Betriebssysteme
WS 2012/13
Aaron Scherzinger
26
Editor
• VIM: www.vim.org
• Aufruf mit vim <dateiname>
• Tutorial: :help
• XEmacs: www.xemacs.org
• Aufruf mit xemacs <dateiname>
• Tutorial: M-? t
• Speichern: C-x s
• Verlassen: C-x c
• Beide Editoren sind auf den meisten Unix-Systemen verfügbar und
äußerst leistungsfähig – das Lesen der Dokumentation lohnt sich!
• NEdit: www.nedit.org
• Einfachere Bedienung
• Windows ähnlich
Übung Betriebssysteme
WS 2012/13
Aaron Scherzinger
27
Compiler – Details
• Die Übersetzung eines C-Programms findet in mehreren Schritten statt
1
2
3
Präprozessor: Textuelle Ersetzung von Präprozessoranweisungen
Compiler: Übersetzung in Maschinencode.
Ergebnisdatei program.o enthält nur Maschinencode von Funktionen
aus program.c. Funktionsaufrufe anderer Funktionen sind speziell
gekennzeichnet.
Linker: Verbindet mehrere .o-Dateien und Bibliotheksdateien zu einem
ausführbaren Programm. Fügt fehlende Funktionen aus .o-Dateien und
Bibliotheken, sowie Code zur Ausführung der Funktion main ein.
• In der Regel werden alle drei Schritte auf einmal erledigt ohne
Mitwirkung durch den Benutzer
Übung Betriebssysteme
WS 2012/13
Aaron Scherzinger
28
GNU C Compiler (gcc)
• Aufruf: gcc <datei.c>
Zusätzlich können noch Optionen angegeben werden:
• -Wall: Viele Warnungen ausgeben (z. B. bei if(a=b) warnen)
• -o <datei>: Name der zu erzeugenden Datei (sonst: a.out)
• Aufruf für die Übungsaufgaben:
gcc -Wall -Werror -pedantic-errors
-o prog prog.c
• Aufruf von gcc bewirkt übersetzen und linken
Verhindern des linkens: -c
gcc -Wall -Werror -pedantic-errors -c
-o prog.o prog.c
• Weitere Optionen:
• -E nur Präprozessor
• -g Einbinden von Debug-Informationen
• -O, -O1, -O2, -O3 Optimierungsstufe
Übung Betriebssysteme
WS 2012/13
Aaron Scherzinger
29
Man-Pages
• Unix Hilfe Seiten
• Anzeige mit man <befehl/funktion/schluesselwort>
z. B. man gcc
• Man-Pages sind in Abschnitte (Sections) untergliedert.
• Abschnitt 1: Benutzerbefehle
• Abschnitt 2: Systemaufrufe
• Abschnitt 3: Bibliotheksfunktionen
• Angabe des Abschnitts: man <abschnitt> <befehl>
•
•
•
•
z. B. man 3 printf
auf Solaris: man -s <abschnitt> <befehl>
Innerhalb von Man-Pages werden andere Seiten oft in der Form
befehl(abschnitt) angegeben, z. B. fork(2)
Nach Hilfeseiten suchen: man -k <Schlüsselwort>
man man
Alternativ www.linuxmanpages.com
Übung Betriebssysteme
WS 2012/13
Aaron Scherzinger
30
Make
• Automatisierte Erzeugung von Programmen aus Quelldateien
• Berücksichtigt Abhängigkeiten zwischen Dateien
stackTest.c
compile
link
stackTest.o
stack.h
stackTest
stack.o
stack.c
• Steuerung der Übersetzung durch Regeln in Datei Makefile
# Ziel: Quellen
# <tab> Befehle
stackTest: stackTest.o stack.o
gcc stackTest.o stack.o −o stackTest
stackTest.o: stackTest.c stack.h
gcc −o stackTest.o −c −Wall stackTest.c
stack.o: stack.c stack.h
gcc −o stack.o −c −Wall stack.c
Übung Betriebssysteme
WS 2012/13
Aaron Scherzinger
31
Make: Implizite Regeln
• Neben expliziten Regeln enthält make implizite Standardregeln, z. B.
Regel zur Erzeugung von datei.o aus datei.c
• Standardregeln sind über Variablen konfigurierbar
Für C-Programme:
• CC: Compiler
• CFLAGS: Kommandozeilenparameter für Compiler
• Anwendung impliziter Regeln wenn Befehle weggelassen werden
CC=gcc
CFLAGS=−Wall −Werror −pedantic−errors −std=c99
stackTest: stackTest.o stack.o
stack.o: stack.c stack.h
stackTest.o: stack.h stackTest.c
• Aufruf mit gmake oder gmake Ziel
Übung Betriebssysteme
WS 2012/13
Aaron Scherzinger
32
GNU Debugger: gdb, ddd
• Aufruf: gdb <programm>
• Vorgehensweise für den Fehler zwischendurch:
• run <Kommandozeilenparameter> startet das Programm
• kill bricht das Programm ab
• break <funktion> setzt breakpoint“ (Ausführung wird bei Beginn
”
von funktion unterbrochen)
• print <ausdruck> gibt Wert von <ausdruck> (beliebige
Programmvariablen, Zeiger, . . . ) aus
• cont führt Ausführung fort
• Bei Absturz: bt ( backtrace“) gibt an, an welcher Stelle das Programm
”
abgestürzt ist
• Graphische Oberfläche für gdb: ddd (Data Display Debugger)
ddd <programm>
Übung Betriebssysteme
WS 2012/13
Aaron Scherzinger
33
Zusammenfassung
• Wichtig für Programmieraufgaben:
• Bei Programmieraufgaben wird ein Makefile zur Verfügung gestellt
• Programme müssen mit diesem Makefile auf einem Rechner des IVV5
(z.B. Räuber) übersetzbar sein
• Alternative zu Linux: Cygwin und MinGW
• ABER: Kein Support durch Tutoren!
• Weitere Alternative: Programm an Heim-PC schreiben und via SSH
auf einem Linux-Rechner übersetzen
• Genaueres zu Makefiles, Debugger in der ersten Globalübung
Übung Betriebssysteme
WS 2012/13
Aaron Scherzinger
34

Übung Betriebssysteme - Übung 1 - Parallele und verteilte Systeme

Produkte

Unterstützung

Übung Betriebssysteme - Übung 1 - Parallele und verteilte Systeme

Dieses Dokument Sammlung (en)

Dieses Dokument gespeichert

Schlagen Sie uns vor, wie wir StudyLib verbessern können