Prozesszustände (1a)

Prozesszustände (1a)
NOT
EXISTING
DELETED
CREATED
– Meta-Zustand (Theoretische Bedeutung)
Prozesszustände – Multiuser Umfeld (1c)
• Hintergrund-Prozess
- der Prozess startet im Hintergrund - my-command.bin &
- der Prozess läuft dann im Vordergrund. Er wird im Betrieb mit
CTRL-Z gestoppt und kann danach in der Shell mit bg (background) in
den Hintergrund geschickt werden. (fg - foreground)
• nice, renice – setzt Prozess-Prioritäten
nice - - 20 important_job.bin (Priorität erhöhen)
nice - + 19 my_fancy_screensaver.bin (Priorität senken)
my-command.bin
while kill –STOP %%; do sleep 4; kill –CONT %%; sleep 1;done
Prozessverwaltung (2a)
• Programm: der Programmtext als installiertes Binary
• Prozess: Ressource des Betriebssystems in der eine Instanz eines Programms
läuft. Ein einmalig vorliegendes Programm kann mehrfach, d.h. in mehreren
Prozessen ausgeführt werden.
• Task/Job: Begriff um einen Prozess zu beschreiben, der von einer bestimmten
Shell aus gestartet wurde und von BS eindeutig identifizierbar ist. Task ist mit
jeweils einem Prozess assoziiert. Job kann mehrere Prozesse bezeichnen, die
im demselben Kontext laufen, z.B. eine Anwendung.
• Kernel-Level-Thread: Ressource des Betriebssystems, d.h. der Kern kümmert
sich um die Ressourcen-Vergabe und das präemptive Scheduling.
• User-Level-Thread: ein per Programmbibliothek eingebundener Scheduler
ermöglicht einem Prozess selber mehrere Threads zu verwalten. Das Programm
muss zur Unterbrechung der Threads und zum Wechsel der Kontrolle geeignete
Maßnahmen ergreifen und ein kooperatives Scheduling selbst durchführen.
• Mischformen: LWPs unter Solaris bilden ohne den Overhead vollwertiger und
damit schwergewichtiger Prozesse User-Level-Threads auf einen Pool von
Kernel-Level-Threads ab. Dies vereint das einfache Management der User-LevelThreads mit den, einem Betriebssystem vorbehaltenen, präemptiven
Fähigkeiten.
Prozessverwaltung
Kernel/User Mode (2b):
• Stabilität
• Datenschutz
• Abstraction/Management
Kernel-Prozesse / Benutzer-Prozesse – Schutz (2c):
Prozessor / MMU – Unterstützung
• Trennung von Segmente/Pages in unterschiedlichen Bereichen
• Privilegierung Flags – 4 Stufen – 3 Normal; (0-2) Superuser
• Assembler Sonderbefehle
Prozesswechsel (2d):
• Interrupts
• Prozessorunterstützung
!!! Parameteraustausch zw. Kernel und User Speicher – nur durch Kopien
Wechsel zum Kernel-Mode – Call-Gates (2d)
0
2:
3: CallGate auf Seg 2, Offset Funk 24
Segment-Deskriptor-Tabelle
4:
Korrekte
Einsprungspunkte
Segment 2, PL0, Kernel
Longjump über CallGate
LONG JMP 3:
Segment 4, PL3, User
MAX
Beliebiges Longjump FALSCH
Speicherverwaltung (3a)
Logischer Speicher
(Benutzer Sicht)
Physikalischer Speicher
Segment
Page
Logischer Speicher
=
1 Segment
.
.
.
Flat Segmentation
.
.
.
Speicherverwaltung (3b)
Logischer Speicher
(Benutzer Sicht)
Physikalischer Speicher
Proz. A
Proz. B
.
.
.
.
.
.
Segment
Page
Koordinierung – konkurrierender Zugriff (4a)
public class Count extends Thread {
static int value=0; //gezählte Wert
boolean reader=false; //Unterscheidung zw. Leser und Schreiber
static Object barrier = new Object(); //Semaphor-Rolle
Count(boolean reader) { this.reader=reader; }
public void run() {
while(true) {
synchronized(barrier) { //warten an der Barriere, synchronized = kritischen Bereich
if (reader) { //Ist das der Leser Thread?
System.out.println("value is "+value);
value=0;
}
else value++;//Wenn das der Schreiber ist
} //Der Leser schläft, um den Schreiber Zeit zum schreiben zu geben
if (reader) try {sleep(1000);} catch(InterruptedException e) { e.printStackTrace(); }
}
}
public final static void main(String[] args) throws Exception {
new Count(true).start(); //Leser Thread
new Count(false).start(); //Schreiber Thread
synchronized(barrier) {barrier.wait();} //Objekt mit Semaphor-Rolle
}
}
Java Semaphor 1 (4c)
public class Semaphore {
boolean s; //Semaphor Variable
public Semaphore { // Semaphor Variable wird über „Semaphore“-Objekt
gesteuert
s = true;
}
// Semaphor Eingang
synchronized public void P() {
while (s == false){
try {
wait();
} catch (InterruptedException e) { }
}
s = false;
}
// Semaphor Ausgang
synchronized public void V() {
s = true;
notify(); //weckt alle wartenden Prozesse
}
}
Java Semaphor 2 (4c)
public class Semaphore {
int s;
public Semaphore {
s = 1;
}
synchronized public void P()
{
while (s <= 0){
try {
wait();
} catch (InterruptedException e) { }
}
s = s - 1;
}
synchronized public void V() {
s = s + 1;
notify();//weckt einen, der wartenden Prozesse
}
}
Java PV-Semaphor (4c)
public class ChunkSemaphore {
int s; //Semaphor Variable
public ChunkSemaphore(int initial) {
s = initial;
}
// Semaphor Eingang
synchronized public void P(int k) throws InterruptedException {
while (s - k <= 0) wait(); // Semaphor ist komplett besetzt - warten
s = s - k; // Semaphor dekrementieren
}
// Semaphor Ausgang
synchronized public void V(int k) {
s = s + k; // Semaphor inkrementieren
notifyAll();// weckt alle wartenden Prozesse
}
}