http://img.pr0gramm.com/2015/02/02/9d66389d798b9043.jpg awwwwww :)thats me <3 was sind das für komische Tabellen? Lernst du was anderes als SP?

SP und davon alles mögliche (Klausuren, Zusammenfassungen, Wichtiges, Spickzettel, interessante Links, was wurde in der Fragestunde besprochen)




Wichtiges, kurze Zusammenfassung(en) zu "was kommt dran?"
//könnte jemand der die Aufgabe mother relativ gut schon von vornherein gelöst hat, mal die korrigierte Fassung (also des PDF) zur Verfügung stellen, eventuell kommt aus dem was dran?
*// hat jemand die rush gut gelöst und könnte seine Fassung zur Verfügung stellen?

meine mother
http://pastebin.com/iUbL95gD


Kleine Statistik dazu welche Themen in den Single/Multiple-Choice-Fragen wie oft dran kamen:
Virtueller Speicher / Adressräume / Speicherverwaltung 20
Dateisysteme / Inodes 13
Prozesszustände / Einplanung / Einlastung 12
Synchronisation / Verklemmung 10
RAIDs 6
Traps / Interrupts / Wiederaufnahmemod. / Beendigungsmod. 5
Seitenersetzungsstrategien 4
Sockets 3
Prozessarten (federgew., schwergew., usw) 2
Freispeicherverwaltung 2
Seitenflattern 2
Segmente 1

Und bei Aufgabe 3/4:
Speicherverwaltung / Seitenersetzungsstrategien 6
Synchronisation / Verklemmung 4
Prozesszustände / Einplanung 3
Freispeicherverwaltung 2
Prozessarten / Gewichtsklassen 2
Dateisystem / Inodes 1
Monitor 1
Traps / Interrupts / Wiederaufnahmemod. / Beendigungsmod. 1



Spickzettel
//eventuell möchte ja der ein oder andere seinen Spickzettel veröffentlichen und hier den Link posten
//aber vlt. reichen auch einfach ein paar kurze Notizen, was man da d3auf packen sollte oder man selber so drauf packt
//auch aus dem Forum
https://fsi.informatik.uni-erlangen.de/forum/forum.php?req=thread&download=123112&inline=1&key=119FDA32  //link geht so net, eventuell ist der key so nicht gültig?!?...
https://dl.dropbox.com/u/92712289/SPZus.rar 
// meiner kommt heut Abend - welches heute? =)kann leider nicht posten das kann keiner lesen :D//ich streng mich an, ich werde mein bestes geben das zu entziffern^^
http://www.bilder-upload.eu/show.php?file=74768f-1423518922.jpg you never had a chance..........//ich wusste nicht das wir eine luppe mitbringen konnten, echt starke sache --jaa. so viel zu "komprimiertem Wissen"
https://www.facebook.com/groups/faui2k13/permalink/861612393898281/
https://www.dropbox.com/sh/064vabeh859cq65/AACRn7BuGis-KbJdXMoy3fEqa?dl=0 Einzelshots der Diagramme, gesamt wäre zu klein - down -.-

https://www.dropbox.com/s/zvw3p6cnzytwsso/Spickzettel.pdf?dl=0 - Falls es jetzt (eine Stunde vor der Klausur)  noch jemandem hilft. Was da nicht steht ist in meinem Kopf ;-)

// noch mehr freie spicker zum inspirieren? :) 

kleine Statistik zu wie weit seid ihr mit eurem Spickzettel:

knotenpunkt: 73,79% abgeschlossen und kein bock mehr....
Nash: 80%, Rest wird morgen früh gemacht
Phyxtra: Knappe 15cm^2 sind noch frei, tips was an Diagrammen zB noch drauf sollte?Ich hab Speicherorganisation und Prozesszustände drauf  
Tikata(100%) :-p Download-Link? ;P
chris: 95% des Papiers. muss reichen.

Seltsam. Im Forum bei sp Suchenach Zusammenfassung. So kommt man an die links:
https://fsi.informatik.uni-erlangen.de/forum/forum.php?req=search&Query=zusammenfassung&ResultView=2&InSubject=1&InMessage=1&Sort=2&DateFrom=&DateUntil=&Forum=18
nudelsalat: noch viel zu viel Platz. :D

Interessante Links:
http://xabuloes.bplaced.net/sp/index.php //solltet ihr euch echt mal anschauen, taugt -glaube ich- wirklich was// hat bei der miniklausur damals schon mega geholfen 
http://wwwcip.informatik.uni-erlangen.de/~hu78sapy/pdf/spexam.pdf <- Lösungssammlungen aus dem FSI 
https://dl.dropboxusercontent.com/u/92712289/SP%20MultipleChoice%20mit%20Ergebnissen.rar
von der Konkurenz: http://www2.cs.uni-paderborn.de/cs/ag-heiss/lehre/kms/kms_5_4.pdf


Fragestunde
also ich kann mich noch an das Ausführliche Besprechen des Buddy-Verfahrens erinnernUnd malloc kam dran,also das Zeichnen
- keine Koroutinen // dh kommen nicht dran?//sehr gut// was sind koroutinen?//anscheinend irrelevant vl. ergänzende Materiallien vl. IX-3
- Signale+Threads, letzter Übungsfoliensatz, eine Folie//wie letzte Folie?//Also Threads statt pthread_create statt fork(Prozesse)
- Signalhandler !!!!!!!!!!11elf //soll das heißen, wir bekommen so ne hässliche Signal-Programmieraufgabe?// das wär ja grauenvoll -- immer. SIGCHLD ist das häufigste Wort in den alten Prüfungen
- Monitore. Aber keine Bildchen//sehr gut

meine "Fassung" der Fragestunde
https://www.dropbox.com/sttps://www./www.d/www.d//www.drottps:www.drottps:rottps:rottps:drottps://www.dropbox.com/s/wglils Ausführliche Besprechen des Buddy-Verfahrenpbox.com/s/wglils Ausführliche Besprechen des Buddy-Verfahren/wglils Ausführliche Besprechen des Buddy-Verfahrenrgpq17dq35/SP%20Fragestunde.pdf?dl=0 // der link scheint nicht zu funktionieren //ah jetzt schon//(y)
//WARUM SOVIEL Speicher-Zeugs... ich mag des zeug irgendwie net, ist so GRA-artig so Threads, Prozesse und Scheduling ist viel cooler finde ich...//(y)eindeutig.

Was ist mit Makefiles, kommen die in der klausur vor =?


In der Fragestunde besprochene Aufgaben

2011-S/3


virtueller Adressraum von P1
0x0000 bleibt leer, damit Zugriff auf Nullpointer -> Segfault
0x1000 t1
0x2000 t2
0x3000 d1
0x4000 d2
0x5000
0x6000
0x7000
0x8000
0x9000
0xa000
0xb000
0xc000
0xd000
0xe000
0xf000 s1

phys. Hauptspeicher
0x0000 BS
0x1000 BS
0x2000 BS
0x3000 BS
0x4000 P1: t1
0x5000
0x6000 P1: d1
0x7000 P1: t2
0x8000
0x9000 P1: s1
0xa000 P2
0xb000 P2
0xc000 P2
0xd000 P2
0xe000 P2
0xf000 P2


b)

logische Adresse  2 - 2 6 0
2 : Seitennummer
2 6 0: Versatz/Offset

Basisregister
   |
   |
   v
    Addr     P Rechte
0   0          0  - - -
1  4000    1  r - x
2  7000    1  r - x
3  6000    1  r w -
4  37000  0  r w -              Adresse auf Swap, kann sein dass die Adresse zu lang ist. Interessiert die MMU aber nicht, weil present = 0.
.
.
.
F  9000    1   r w -

-> phys. Adresse: 7 2 6 0

c)
1.
a global, nicht initialisiert. -> d1 / d2
b global -> d1 / d2
p lokal, static -> d1 / d2
i: lokal -> s1

2.

3.
- Pagefault
- freien Seitenrahmen suchen
- Seite einlagern
- Seitendeskriptor aktualisieren
- Trap-Routine verlassen, Befehl wird wiederholt






2012-W / 1.2b)

1. [  ] FCFS gut bei vielen kleinen Sachen
2. [X] E/A intensive Prozesse nutzen ihre Zeitscheibe nicht aus.
3. [  ] bei VRR werden E/A intensive Prozesse eher bevorzugt.
4. [X] yes
5. [  ] man braucht Interrupt
6. [  ] Echtzeitsysteme zB
7. [X]
8. [X] und sie dachten, es sei richtig :D



2014-W / 3c)

kooperativ
- Prozesse geben freiwillig ab [oder wird im Rahmen eines von ihm getätigten Systemaufrufs verdrängt]
- Prozesse können CPU monopolisieren
- FCFS, zB sehr kurz laufende Prozesse

präemptiv // round robin ist doch nicht präemptiv  //doch!
- Prozesse werden verdrängt
- Typisch mehr Mehrbenutzer/Timesharing-Systemen
- RoundRobin, Feedback


3d)

schwebend bereit         <----->  bereit    <------> laufend
^                                                          ^                       |
|                                                           |                       |
|                                                           |                      v
schwebend blockiert <------------> blockiert............

laufend -> bereit [relinquish]
präemptiv:gewaltvoll
kooperativ: freiwillig



2013-W

1.2a)
[X] Zuordnung Threads-CPU im Systemkern
[  ] sind nur auf Anwendungsebene
[X] yes
[  ] ne
[  ] nope
[X] jap
[  ] hat nichts miteinander zu tun
[  ] nein

b)
[  ] nein, da nur 2^b
[X] entweder besonders einfach oder es geht garnicht!
[  ] nein das geht nicht immer.
[X]
[  ] nein, nur andersrum sortiert [Listen sind nach Größe sortiert, nicht nach Adresse]
[X] jap
[  ] free ist kein Systemaufruf
[X] jap, Nachbarn sind nebenan
//tach nudelsalat :D



2011-W 3 (2012 Februar)

Was ist ein Monitor, welche Operationen?
//was ist alles ein Monitor, könnte vlt. jemand kurze Stichworte dazu geben
Hansen/Hoare/Hansen sind ja Konzepte die Monitore verwenden, ist dann der Monitor das Konzept selber oder sind Monitore diese Kritschen Abschnitte
//wäre cool wenn des mal jemand genau definieren würde...
//und was sind dann die operationen?
Also auf meinem Spickzettel steht: Datentyp mit impliziten Synchronisationseigenschaften
Funktionen: enter, leave, wait, signal


Schon wichtig.

a)


a1)
Monitor ist ein Konstrukt der Programmiersprache
Sonst explizite Funktionsaufrufe [Locks], nicht an programmiersprachlice Scopes gebunden

a2)
lock / unlock [/ enter / leave] / wait / signal
Monitor ist ein kritischer Abschnitt. -> enter / leave

wait: atomar! krit. Abschnitt aufgeben


Hoare: beim aufwachen darf man sicher weiter laufen.


a3)
gegenseitiger Ausschluss: mehrseitige Sync bei enter/leave
wait: einseitige Sync.

(aus dem fsi)
Klausur Februar 2012, Aufgabe 3a: 
(http://www4.cs.fau.de/Lehre/WS11/V_SP2/Pruefung/2011w-SP-K…)

 (groben) Antworten:
a1) 
pthread:
- Mutexe
- Joins
- Cond_Var

Monitor:
- Kapselung, Datenabstraktion, Bauplan durch Monitorkonzept (= Modul) -> Abstrakter als phtread 
- Von Proz. gemeinsam genutzte Daten zu einer Einheit zusammengefügt
- Programmierer muss sich nicht mehr explizit um die Art der Synchronisation kümmern

a2)
mehrseitiger Synchronissation: Schlossvariablen o. Semaphore (bevorzugt)
einseitige Synchronissation:
- Bedingungsvariable
- Monitor-Operationen werden unter wechselseitigem Ausschluß ausgeführt

Im Bezug auf Hansen/Mesa:
-  Hansen: block. Bed.var.; gibt dem Signalnehmer Vorrang ->   Signalisierung lässt den Signalgeber den Monitor verlassen, nachdem er   alle Signalnehmer auf  "bereit" gesetzt hat
-  Mesa: nichtblock. Bed.var.; gibt dem Signalgeber Vorrang ->   Signalisierung lässt den Signalgeber im Monitor fortfahren, nachdem er   einen oder alle Signalnehmer auf "bereit" gesetzt hat

a3) einseitige/mehrseitige Synchronisation (also ähnlich wie a2), nur im Kontext der eins./mehrs. Synchr. erklärt)





ww

//nudelsalat ne Frage, könntest du eventuell auch noch ein bisschen reinschreiben, was sonst so besprochen worden ist, also nicht nur die aufgaben sondern so background-wissen oder so
//würde mich auch sehr interessieren ~ joa je nachdem, wie viel und wie wichtig es ist.+1
//naja mich würde auch des unwichtige ein bisschen interessieren, eventuell das was zu Monitoren und pthread_create geklärt worden ist vlt. kannste dazu ja ein bisschen was schreiben, wäre echt super nett von dir^^





Klausuren
//eventuell überflüssig wg. gutem Link(siehe oben!)
//aber wer möchte kann sich ja trotzdem hier noch etwas versuchen

kann jemand villeicht die herangehensweise an die Programieraufgabe hier aufschreiben? (bin selbst gerade noch bei wiederholen der Folien, weiss nicht wann ich es schaffe.)
es gibt wenn ich das richtig verstanden habe 3 Aufgabetypen: 
i) Shell-ähnlich
ii) Server-ähnlich
iii) buffer-ähnlich
es gibt (fast identische) vorgehsweisen, vielleicht sitzt jemadn gerade dran, und kann die für die jeweilige Aufgabe kurz benötigte Methoden in der jeweiligen Reinfolge notieren, wäre für alle beteiligten super hilfreich, wollte eigentlich selbst machen aber scheint, so dass ich erst dienstag dazu komme, zu spät angefangen .... :'-)// setz mich spätestens morgen dran :) // wie siehts aus? ;)

Klausureninhaltsverzeichnis:

1: Klausur SS14: https://www4.cs.fau.de/Lehre/SS14/V_SP2/Pruefung/2014s-SP-Klausur-www.pdf



Klausuren:



Klausur Wintersemester 2012:


//muss man bei 3a) des in dieser komischen verzeigerungsstruktur hinschreiben?
//kann mir jemand des buddy-verfahren genauer erklären,wieso weshalb und warum des so gemacht wird, wie unten angegeben

//ist mitschrift aus der 1. Fragestunde von vor 2-3? Wochen
WS 3a)

initial:
624|400 -> 300|60

1 malloc(300 )
324|700 -> 300|60

2 malloc(50)
300|60 -> 274|750

3 malloc(70)
274|750 -> 230|130

4 malloc(200)
230 |130 ->74|950

5 malloc(60)
170|190 ->74|950

das ist jetzt worst-fit


3b) Buddyverfahren:
initial 
-
512
256
128
-
-
     |:::::::::|               |                       |                              |
            128           256               512

malloc(300)

Da  Malloc 300 und im Buddyverfahren nur zweierpotenzen => 512 belegen,  wir sehen 512 ist frei  => 512 belegen und aus der Freispeichertabelle löschen 

     |:::::::::|             |                       |:::::::::::::::::::::::::::::::::::::::::::::|
            128         256               512

1024 -
512   -
256   -256
128   - 128
64     -
32     -



malloc(50)
Da   Malloc 50 und im Buddyverfahren nur zweierpotenzen => 64belegen,   wir sehen 64  gibt es nicht , also gucken wir eins drüber- wir sehen bei 128 ist was frei (addr: 128) ,  128 kann man aber noch teilen /2 => 64 
wir teilen es und belegen ab addr. 128   64 bit => bis addr. 192 => es wird ein neuer Speicherblock noch frei, nämlich die andere hälfte des gerade geteilten 128 blocks =>  64 großer block ab 192
     |:::::::::|:::::::|         |                       |:::::::::::::::::::::::::::::::::::::::::::::|
            128  192   256               512


Größe | Addr
1024   |
512     |
256     |256
128     |  
64       |192
32      | 





malloc(70)
   weil 192 nur 64 groß ist
malloc(70) =>  128 , da 192 zu klein, nehme 256  - teile 256 durch 2 

     |:::::::::|:::::::|         |::::::::::::::|            |:::::::::::::::::::::::::::::::::::::::::::::|
            128  192   256      384    512


Größe | Addr
1024   |
512     |
256     |
128     |384  
64       |192
32      | 



malloc(200)
null (not enough memory)
     |:::::::::|:::::::|         |::::::::::::::|            |:::::::::::::::::::::::::::::::::::::::::::::|
            128  192   256      384    512


Größe | Addr
1024   |
512     |
256     |
128     |384  
64       |192
32      | 



malloc(60)


null (not enough memory)//passt doch rein
     |:::::::::|:::::::|:::::::::|::::::::::::::|            |:::::::::::::::::::::::::::::::::::::::::::::|
            128  192   256      384    512


Größe | Addr
1024   |
512     |
256     |
128     |384  
64       |
32      | 








Klausuren letzter "TheorieTeil"
April 2010:
Aufgabe 3:
a. //schreiben sie pseudocodeÄhnlich die Funktionen "put" und "get" eines Ringpuffers fester Größe,koordinieren sie die Funktionen mit Hilfe von Semaphoren
Beschreiben sie kurz die Bedeutung der von ihnen eingesetzten Semaphoren und welche Werte sie initialisiert haben müssen.Gehen sie davon aus,dass auch mehrere
Erzeuger und Verbraucher gleichzeitig einen Zugriff versuchen können.
void bbPut(BNDBUF *bb,int value){
void bbGet(struct data *data){

b.
Die Verwendung blockierender Synchronisatzionsverfahren ist nicht immer Unproblematisch. Beschreiben sie 3 Problembereiche,die blockierende Synchronisation mi
t sich bringen kann.buddyworst-fit
1. "spinn lock" reduziert ggf. massiv die Busbreite
2.Robustheit: EIn im kritischen Zustand scheiternder Prozess kann im worst case das ganze System lahmlegen
3.Einplanung: wird behinder/nicht durchgesetzt,weniger wichtige Prozesse können wichtige ausbremesen=>prioritätenumkehr
4. Verklemmung einer oder mehrere Prozesse
c. Im get() in dem Bespiel aus den Übungen haben wir iN(nächster Freier Platz) und iNnext (der Berechnete neue Platz) durch CAS geschützt,CAS prüft in einer Schleife, ob die kritische Variable
nebenläufig verändert wurde. Im allg. können wir bb->Erz und bb->Ver mit nicht blockierender synch. ersetzen.
d. Hab ich oben eigentlich schon erklärt^^

Aufgabe 4;// kann die wer beantworten,mit den Tipps?
Beschreiben sie die unterschiedlichen Arten von Gewichtsklassen von Prozessoren
-    schwergewichtiger Prozess: Prozessinstanz und Benutzeradressraum bilden eine Einheit; horizontale Isolation: jeder Faden besitzt eigenen Adressraum, Umschaltung nur mit BS
-    leichtgewichtiger Prozess: Prozessinstanz und Adressraum voneinander gekoppelt; vertikale Isolation: Steuerbefehle und Syscalls an den Betriebssystemkern
-    federgewichtiger Prozess: Prozessinstanzen und Adressraum bilden eine Einheit; eigentlicher Kontrollfluss(Thread), keine Isolation
Die Gewichtsklassen sollen hinsichtlich der folgenden Kriterien verglichen werden:

Klausur vom Juli 2010:
    
Aufgabe3:
Bei Ausnahmesituationen,wie sie bei der Ausführung von Programmen auftreten können werden Traps/Interrupts unterschieden
a. Beschreiben sie die beiden Arten
b.Man unterschiedet bei der Ausnahmebehandlung Wiederaufnahmemodell und Beendigungsmodell.Was versteht man darunter und bei welchen Ausnahmen kann wie verfahren werden

c.Wie wird eine Ausnahmebehandlung von der CPU abgewickelt? // wollen die hier das hören,oder was anderes?
Aufgabe4:
    // kann jemand hier vllt nochmal auf die Anwendungssituationen schauen?
Scheduling:
Geben sie konkrete Beispiele an und und in welcher Anwendungssitution entsprechende Strategien sinncoll eingesetzt werden
a. kooperatives/preemtives 
FCFS:Prozesse werden nach Ankunftszeit eingeplant,nicht-verdrängendes Verfahren, setzt kooperative Prozesse voraus, hohe Antwortzeit,niedriger E/A durchsatz suboptimal bei mixen von kurzen und langen CPU stößen,problem ist der Konvoi effekt kurze folgen langen Prozessen. => sinnvoll bei keinen Echtzeitsystemen!Sehr einfach zu implementieren 
SPN:nach erwarteter Bedienzeit eingeplant,a priori wissen über prozesslaufzeit.Stapel:Programmierer setzt fristen,produktion: statistisch durch probeläufe,dialog:abschätzung zur laufzeit. Abarbeitung einer aufsteigend dortierten bereitliste
1: Klausur SS14: https://www4.cs.fau.de/Lehre/SS14/V_SP2/Pruefung/2014s-SP-Klausur-www.pdf

Aufgabe 1.1: Einfachauswahl-Fragen (22 Punkte)

a) Man unterscheidet die Begriffe Programm und Prozess. Welche der folgenden Aussagen zu diesem Thema ist richtig? Antwort[2]
b) Man unterscheidet Traps und Interrupts. Welche Aussage ist richtig?Antwort[2]
c) Welche Aussage zum Thema Threads ist richtig? Antwort[3]
d) Welche Aussage zum Thema Adressraumschutz ist richtig? Antwort[3]
e) Welche Aussage zum Thema Betriebsarten ist richtig? Antwort[1]
f) Welche Aussage zum Thema Speicherverwaltung ist richtig? Antwort[2]
g) Welche Aussage zu Zeigern ist richtig? Antwort[4]
h) Welche Aussage zum Thema RAID ist richtig? Antwort[4]
i) Welche Aussage zum Thema Schedulingverfahren ist richtig? Antwort[3]//warum?  2 könnte auch sein
j) Für lokale Variablen, Aufrufparameter, etc. einer Funktion wird bei vielen Prozessoren ein Stack-Frame angelegt. Welche Aussage ist richtig? Antwort[3]
k) Virtualisierung kann als Maßnahme gegen Verklemmungen genutzt werden. Warum? Antwort[2]

Aufgabe 1.2: Mehrfachauswahl-Fragen (8 Punkte)

a) Welche der folgenden Aussagen zum Thema Prozesszustände sind richtig? Antworten[ ich hab 3,4, 8]//was ist mit 6?, der normale scheduler setzt den prozess doch auf bereit, nur wenn der prozess gerade versucht von E/A was zu lesen und die Daten sind noch net da, dann kommt er durch eigenes Zutun(durch das, dass er versucht Daten zu lesen) in den Zustand blockiert, also er ist in gewisser weise selbst schuld dass er dahin kommt (übernehmen muss dass ganze aber dennoch der Schedular, doer?)
b) Welche der folgenden Aussagen zu UNIX-Dateisystemen sind richtig? Antworten[ich hab 2,3,5,6]//was ist mit 8? Pro Unterverzeichnis kommt doch ein .. hinzu?hmm.. es wird davon beinflusst, hängt aber nicht ausschließlich davon ab, außerdem ist ja eigentlich das unterverzeichnis eines unterverzeichnisses auch ein unterverzeichnis von mir , erhöht aber nicht die hardlinks//deren ".." würden dann ja auf das unterverzeichnis verweisen. ein 'mkdir /tmp/bla/a', gibt mit 'ls -l /tmp/bla' für a 2 links aus. kommt dann noch 'mkdir /tmp/bla/a/1' und 'mkdir /bla/a/2' hinzu, zeigt er schon vier an. das meinte ich aber nicht - eher so dass wenn jetzt tmp/bla/a/1/42  dazukommt ist 42 ein unterverzeichnis von "a" aber die anzahl der hardlinks auf "a" erhöht sich nichtokay, verstanden was du gemeint hast! 


Aufgabe 2: vsc (60 Punkte)
vsc - aktuellere Version:
    
    #define FRAME_SIZE 640*480
struct data {
char frame[FRAME_SIZE];
int eof;
};

#include <dirent.h>
#include <errno.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include "jitbuf.h"

static void die(const char message[]) {
perror(message);
exit(EXIT_FAILURE);
}


// weitere Includes, Konstanten
// globale Variablen, Funktionsdeklarationen usw.
void *showFrame(void);
#include <fnmatch.h>


// Funktion main()
static int main(int argc, char** argv){

        if(jbInit() != 0){
                fprintf("Error creating jb");
                exit(EXIT_FAILURE);
        }
        
        phtread_t tid;
        
        errno = pthread_create(&tid, NULL, showFrame, NULL);//show Frame soll nach angabe glaube ich (void) als parameter haben
        
        if(errno !== 0){
                perror("thread");
                exit(EXIT_FAILURE);
        }
        
        
        // Socket erstellen und Verbindungsannahme vorbereiten
        int ls, cs;
        
        struct addrinfo hints={
                .sin6_family = AF_INET6,
                .sin6_port = htons(2014),
                .sin6_addr = in6addr_any,
        }
        
        if(ls = socket(AF_INET6, SOCK_STREAM, 0) == -1 ||
                bind(ls, (struct sockaddr*) &hints, sizeof(hints)) == -1 ||
                listen(ls, SOMAXCONN) == -1){
                perror("socket, bind or listen");
                        exit(EXIT_FAILURE);
                }
                
        // Verbindung annehmen und Verarbeitung vorbereiten
    if(cs = accept(ls, NULL,NULL) == -1){
            perror("accept");
    }        
        
        FILE* reader = fdopen(cs, "r");
        if(reader == NULL){
                perror("openStream");
                exit(EXIT_FAILURE);
        }
        
        struct data *video = malloc (sizeof(struct data));//warum mallocen und net aufm stack anlegen  struct data video;//genau so hätte ich es auch gemacht knoti^^
        
        // Videobilder einlesen und in den Puffer schreiben
        
        size_t bytesRead = 0;

        while((bytesRead = fread(video->frame, sizeof(byte), 307200, reader)) != 0){
        
        if(bytesRead < 307200){//braucht man hier net eher feof() und kann die byte anzahl einfach untern tisch kehren^^//jo
                video->eof = 1;//dann brauchst du aber auch noch ein break; oder so
        }else{
                video->eof = 0;
        }
        
        jbPut(video);
        video = malloc (sizeof(struct data));//warum?, stack sollte reichen
                
        }
        
        errno = phtread_join(tid,NULL);//rfür was braucht man pthread_join? 
        
        if(errno != 0){
                perror("pthread join");
                exit(EXIT_FAILURE);
        }
        
        if(close(ls) != 0 || close(cs) != 0){
                die("close sockets");
        }
        
        if(fclose(reader) == EOF){
                die("closing reader");
        }
        
        exit(EXIT_FAILURE);

}

// Ende Funktion main


// Funktion showFrame
// Ausgabegeräte suchen
        
void * showFrame(void){//hat  übergabeparameter void , verträgt sich also nicht mit der  pthread_create funktion weil die erwartet ein void * ->voidpointer  als übergabe
        
        DIR *d;
        if((dir = opendir("/dev") == NULL){ 
                perror("opendir");
                exit(EXIT_FAILURE);        
        }
        
        struct dirent e;
        errno = 0;
        int nFiles = 0;
        FILE * outFiles[10];
        
        while((e= readdir(d)) != NULL && nFiles < 10 ){
                        
                        if(fnmatch( "fb*", e->d_name, 0) == 0){
                                
                                /********edit changed**********/
                                char path[strlen("/dev/") + strlen(e->d_name)];
                                sprintf(path, "/dev/%s", e-d_name);
                                
                                outFiles[nFiles] = fopen(path, "a+");//VORSICHT:  du musst schon den kompletten pfad übergeben -> strcat mit /dev/ und  e->d_name, oder hab ich des falsch im kopf???? (also könnte schon  stimmen, bin mir gerade net ganz sicher)// habs wie er...ohne pfad//FILE *fopen(const char *path, const char *mode);  - habs angepasst
                                 // das Arbeitsverzeichnis ist ja nicth in /dev von daher muss man denke  ich schon den absoluten pfad angeben, weil der relative bezieht sich ja  aufs Arbeitsverzeichnis und des kann irgendwo sein, oder?
                                also ich denke du hast recht - hier muss man wohl den gesamten Pfad übergeben.
                        
                                if(outFiles[nFiles] == NULL){
                                        perror("opening File");
                                        continue;
                                }
                                
                                nFiles++;
                        }
        }
        
        
        // Videobilder aus Puffer entnehmen und ausgeben
        struct data *video;
        
        
        int eof = 0;
        while(eof == 0){
                jbGet(video);
                
                for(int i = 0; i < nFiles; i++){
                        fwrite(video->frame, sizeof(byte), 307200, outFiles[i]);//  ich hab da irgendwas anderes eher sowas: fwrite(datax.frame,  FRAME_SIZE, 1, FRAME,fopeners[anz2]); //aber meins kann auch kompletter  unsinn sein, kannst du mir mal deine lsg erklären, wie man da drauf  kommt?// alsi cih hab fwrite(video->frame,1,FRAME_SIZE,hier muss irgendwie der stream rein^^);//ja schon datax.frame sind meine daten und foperns[anz] mein stream, so aber jetzt geh ich wirklich ins bett gn8 dir
                }
                
                eof = video->eof;
                free(video)//nachdem  du das video geschrieben hast, kannste es ja wieder neubelegen also nen  stack-cache davon, dafür brauchst du kein malloc oder free
                if(fclose(outFiles[i]) == EOF){
                        die("fclose");
                }
                
        }
        
        
}        
        
// Ende Funktion showFrame

/**************************************************************
* Datei jitbuf.c
*************************************************************/
#define CACHE_SIZE 100
#define BUFFER_SIZE 20

static volatile size_t readPos;
static volatile size_t writePos;
static SEM* fullSlots;
static SEM* freeSlots;
static SEM* waiter;
static size_t itemsBuffered;
static struct data cache[CACHE_SIZE];


// Funktion jbInit
int jbInit(void){


        waiter = semCreate(0);
        freeSlots = semCreate(CACHE_SIZE);
        fullSlosts = semCreate(0);
        
        if(waiter == NULL || fullSlots == NULL || freeSlots == NULL){
                frpintf("error creating needed sems");//kann man free auf Null aufrufen, ja stimmt müsste gehen....//hier stimmt das meiner meinung nach nicht,da du jenachdem wiewiet du ohne fehle rkommst verschieden freen musst - das glaub ich nicht . is in dem fall ja egal, weil die nicht ineinander                                                          verschachtelt                                                    sind
                semDestroy(waiter);
                semDestroy(fullSlots);
                semDestroy(freeSlots);
                return 1;
        }

        itemsBuffered = readPos = writePos = 0;//ist schon implizit auf 0

        return 0;
}

// Funktion jbPut
void jbPut(const struct data *data){//returnen und nicht einfach Blockieren? //war schon ein P, ein P wie Plockieren und ein V wie Vreigeben,asooo meine Eselsbrücke

        if(itemsBuffered >= CACHE_SIZE) 
                return;
                
        P(freeSlots);

        cache[writePos] = data; //Sollte hier bzw weiter unten nicht stehen: cache[writePos] = *data; ? Das Array speichert Structs und nicht pointer. geht das so, oder braucht man memcpy?.
//sollte ohne memcpy gehen. Siehe Rudis kommentar im thread zu der aufgabe im forum//wo steht der kommentar?//sollte eh alles ganz ohne malloc gehen, weil cache ne fixe groesse hat und wie gesagt den dateninhalt statt die pointer speichert XXXXX= *YYYYY holt sich den inhalt von YYYYY und speichert den in XXXXX und das ist sozusgagend ein internes memcpy^^(also das =) //darfst aber den foren link trotzdem noch posten, würde ich mir mal anschauen wollen...
//https://fsi.informatik.uni-erlangen.de/forum/thread/12359-vsc-Klausur-s2014
//letzter kommentar in den thread.// ja da steht genau des mit dem = (ich glaube rudi meint, dass das structs kopieren über diese = operation schon seit C89 geht oder aber memcpy????, bin mir da net ganz sicher was er meint, aber = geht aufjedenfall)
// = sollte gehen für structs, joa//bei was braucht man eigentlich memcpy überhaupt? realloc implementieren :D ne, memcpy is für zeug aufm heap glaub ich.//naja heap kann ich auch derefernzieren und mit = vollschreiben// eventuell array operationen also wenn ich ganze arrays kopieren will die nicht innerhalb eines structs sind???//das auch, ja. Aber hier liegt ja das ganze array aufm stack, weils im struct ist, ist also hier kein problem. //ja des im struct ist klar, aber würde denke ich auch gehen wenns aufm heap liegen würde (also nicht aufm stack)
//hm stimmt, müsste derefenziert werden der pointer, habs zwar jetzt hier nicht getestet, aber sollte schon so sein
//ok net ganz richtig für arrays mit variabler länge gilt das nicht da sinds ja nur pointer und da werden pointeradressen einfach kopiert und nicht mehr


        writePos++;//geht glaube ich auch infix, da ++ post-inkrement ist, also danach ausgewertet wird  cache[writePos++] = data; 
        
        // writepos wieder auf 0 setzen?
        // if(writePos >= CACHE_SIZE) writePos = 0;
        
        V(fullSlots);
        itemsBuffered++;

        if(itemsBuffered == BUFFER_SIZE){//ah cool, glaube da wäre ich wirklich net so schnell drauf gekommen des so zu lösen
                V(waiter);
        }
        
        
        
}

// Funktion jbGet
void jbGet(struct data *data){
        
        P(waiter);
        P(fullSlots);
        
        data = cache[readPos];
        
        readPos ++;
        /*
        struct data dat = cache[readPos++];
        itemsBuffered--;                                       // würde der buffer mit folgendem Szenario: itemsBuffered = Buffer_SIZE => V(waiter) , dann Get, Get, dann Put und dann läuft der Buffer wieder in itemsBuffered = Buffer_SIZE => V(waiter)  => V ist jetzt (2) => synch in Get nichtmehr gewährleistet, oder irre ich mich da?
        data = &dat;https://wwwcip.cs.fau.de/~ak53efan/sp/
          if(readPos >= CACHE_SIZE) readPos = 0;
        */        
        
        V(freeSlots);
        V(waiter);

}

// Funktion jbFlush

void jbFlush(void){
        
        V(waiter);
        
}



Aufgabe 3: (22 Punkte)

Zur Koordinierung von nebenläufigen Vorgängen, die auf gemeinsame Betriebsmittel zugreifen, unterscheidet man zwischen einseitiger und mehrseitiger Synchronisation.
a) Beschreiben Sie die Unterschiede zwischen einseitiger und mehrseitiger Synchronisation. (2 Punkte)

- einseitige Synchronisation: konsumierbare Betriebsmittel, Bedingungssynchronisation, logische Synchron.
- mehrseitige Synchronisation: wiederverwendbare Betriebsmittel, blockierdende/nichtblockierende Synchron.
Siehe Klausur Juli 2013 Aufgabe 4 a)

b) Beschreiben Sie für einseitige und mehrseitige Synchronisation jeweils eine typische Situation, in der ein Synchronisationsproblem der jeweiligen Art auftritt. Wählen Sie dazu jeweils ein geeignetes Synchronisationsverfahren und skizzieren Sie in Pseudocode den Ablauf der jeweiligen Synchronisationssituation. (9 P.)
Einseitig: (vgl https://www4.cs.fau.de/Lehre/WS14/V_SP2/Vorlesung/Folien/SP2-103-A4.pdf Seite 24)
Beispiel: Consumer - Producer Ohne zwischenspeicher für Daten -> Ohne Synchro gehen Daten verloren
Code:
char data; 
semaphore_t full = {0, 0}; 

char consumer() { P(&full); return data; } 
void producer(char item) { data = item; V(&full); }

Mehrseitig:
Mehrere Threads lesen aus Ringbuffer. nichtblockierende synchronisation
Code:
SEM * full;
SEM * free;
int get_value()
{
    P(full);
     int ret;
     do {
    } while (prüfe read_pos und lasse es synchronisiert foranschreiten);
    
    V(free);
    return ret;
}

c) Synchronisation erfolgt in sehr vielen Fällen mittels blockierender Verfahren. Welche Probleme sind mit dem Einsatz blockierender Synchronisation verbunden? (4 Punkte)

- Leistung : reduziert ggf. massiv Busbandbreite 
- Robustheit: ein im kritischen Abschnitt scheiternder Prozess kann schlimmstenfalls das ganze System lahm legen 
- Einplanung: wird behindert bzw. nicht durchgesetzt un- bzw. weniger wichtige Prozesse können wichtige Prozesse ” ausbremsen“ bzw. scheitern lassen
- Verklemmung einiger oder sogar aller Prozesse

d) In manchen Situationen kann man statt mit blockierender Synchronisation mit optimistischen, nichtblockierenden Synchronisationsverfahren arbeiten. Beschreiben Sie an einem kleinen Beispiel (z.B. unter Verwendung eines CAS-Befehls), wie solch ein Verfahren vom Prinzip her arbeitet. Nennen Sie jeweils zwei Vor- und Nachteile solcher Verfahren. (7 Punkte)
Vorteil: 
    - Erhöhte Parallelität
    - Verklemmungsvorbeugung
    
Nachteil:
    -  CAS schreitert -> komplette Transaktion muss wiederholt werden
    - Verhungerungsgefahr
    
Beispiel:
    Lesen aus Ringbuffer. Der zu lesende Wert muss mittels einem read index geholt werden, wobei der read index mittels __sync_compare_bool_and_swap atomar geprüft und verändert werden muss.


Aufgabe 4
a) Bei virtuellem Speicher kann es zu Seitenfehlern (page faults) kommen. Beschreiben Sie eine Situation, in der solch ein Seitenfehler auftritt und was das Betriebssystem zu seiner Behebung tun muss

page fault => MMU Trap auslösen => Prozess in E/A Stoß zwingen => erwarteten Programmteil einlagern (ggf andere Programmteile aus Hauptspeicher verdrängen) => CPU-Stoß wieder aufnehmen


b) Falls kein freier Seitenrahmen im Hauptspeicher verfügbar ist, muss eine Seite ausgelagert werden. Eine mögliche Strategie zur Bestimmung der zu verdrängenden Seite ist LRU. Beschreiben Sie diese Strategie kurz und erläutern Sie, welche Probleme bei der Realisierung bestehen

least recently used: das am längsten nicht mehr genutzte Fragment wird verdrängt.
Probleme? aufwändige Implementierung?


c) Eine in der Praxis gut einsetzbare Approximation dieser Strategie ist Second Chance (oder Clock). Beschreiben Sie die Funktionalität dieser Strategie und welche Unterstützung durch die MMU dafür erforderlich ist

arbeitet im Grun            de nach FIFO, berucksichtigt jedoch zusätzlich noch die Referenzbits der jeweils in Betracht zu ziehenden Seiten. periodisch (Zeitgeber, Tick) werden die Seitendeskriptoren des (unterbrochenen) laufenden Prozesses untersucht

Unterstützung durch die MMU??




Klausur Juli 2013

Aufgabe 1

(meine lösung, ka obs stimmt)
1.1)
a, 2
b, 2//was ist an 1 falsch?//bin nicht sicher. Glaub aber jetzt auch, dass es eher 1 ist. Dachte static liegt alles im Data Segment, aber z.B. static hilfsfunktionen liegen ja im Textsegment. Aber zählen static hilfsfunktionen als variable?//könnte man bestimmt irgendwie so auslegen. ich hätte jetzt 1 und 2 als richtig eingeschätzt...
//laut http://wwwcip.informatik.uni-erlangen.de/~hu78sapy/pdf/spexam.pdf ist es 2
//laut derselben lösung, ist meine lösung aber auch teilweise falsch ^^//hm :-p naja vllt offenbart sich ja noch jemand mit ahnung
c, 3
d, 1
e, 1
f, 3
g, 3
h, 1
i, 1
j, 2
k, 4

1.2)
a: 2,(5?), 6,7,8
b: 1,2,4,5



Aufgabe 3

a) Wie wird bei Speicherzugriff erkannt, dass entsprechender Speicherbereich ausgelagert ist?
MMU, Seitendeskriptor, Present-Bit, Trap der MMU

b) Erkennung? Schritte des BS? Prozesszustände?
page fault -> MMU löst Trap aus und stößt Betriebssystem zum Laden der Seite auf
Prozess: laufend -> blockiert
BS sucht Seite: wenn keine passende vorhanden oder keine Rechte: Segfault
Wenn doch: Seite wird eingelagert an freier Stelle oder verdrängt andere Seite nach dem Ersetzungsverfahren. Seitendeskriptor wird aktualisiert, Present-Bits gesetzt, Prozess erhält Interrupt
Prozess: blockiert -> bereit. Prozess fängt den Befehl, der zum Trap geführt hat nochmal komplett von vorne an


Aufgabe 4

a)
Einseitige / Mehrseitige Synchronisation:
    Einseitige Synch: 
Warten auf eine Bedingung
bei Prozesshierachy - es kann nur einer Unterbrochen werden
Bsp. Signalbehandlung  => Prozess muss gegen Signalbehandlung gesichert werden aber nich umgekehrt
Auswirkung nur auf einen der Prozese

Mehrseitige Synch:
Semaphore
Gleichberechtigte Prozesse
Auswirkung auf alle beteiligten Prozesse


b)
wiederverwendbar : Speicher            - begrenzt, werden angefordert   BsP. Prozessoren, Geräte, Speicher
konsumierbar: Signale                  - unbegrenzte anzahl    Bsp: Signale, Nachrichten Interrupts


c)
// denkt ihr das reicht hier, oder muss man nen wirklichen "Pseudocode" schreiben?
Mehrseitige Synchronisation:
Gegenseitiger   Ausschluss für kritische Abschnitte
Limitierung:    SemCreate mit M um M limitierung
Problem - Zugriff auf gemeinsame Synch.

Einseitig Synchronisierung:
Signalisierung: mit 0 initialisierte Semaphore ----- und P in einer Schleife - warten bis anderer Prozess V macht
Problem: bounded Buffer - Schutz vor Überlauf, Bereitstellen von Zwischenergebnissen.