Du befindest dich hier: FSI Informatik » Prüfungsfragen und Altklausuren » Prüfungen im Bachelor-Studium (1. - 5. Semester) » Lösungsvorschlag (Übersicht)
Unterschiede
Hier werden die Unterschiede zwischen zwei Versionen der Seite angezeigt.
Nächste Überarbeitung | Vorherige Überarbeitung | ||
pruefungen:bachelor:2013w-sp-klausur-loesung [28.07.2015 14:22] – angelegt Anola | pruefungen:bachelor:2013w-sp-klausur-loesung [15.02.2017 18:34] (aktuell) – Veraltete, redundante Infos gelöscht. Im Pad ist's aktueller Marcel[Inf] | ||
---|---|---|---|
Zeile 1: | Zeile 1: | ||
====== Lösungsvorschlag ====== | ====== Lösungsvorschlag ====== | ||
+ | Restliche Aufgabenlösungen siehe Pad: https:// | ||
- | + | ==== Aufgabe 2: ==== | |
- | ==== Aufgabe | + | |
- | + | ||
- | **a)** | + | |
- | **b)** 2 | + | |
- | **c)** 1 | + | |
- | **d)** 3 | + | |
- | **e)** 2 | + | |
- | **f)** 1 | + | |
- | **g)** 3 | + | |
- | **h)** 2 | + | |
- | **i)** 4 | + | |
- | **j)** 4 | + | |
- | + | ||
- | + | ||
- | ==== Aufgabe 3: ==== | + | |
**a)** | **a)** | ||
+ | <code cpp> | ||
- | Kurzfristige Planung: | + | /* Klausur Februar 2014 - Aufgabe 2: mops */ |
- | bereit nach laufend: dispatch | + | |
- | laufend nach bereit: relinquish | + | |
- | (schwebend) blockiert nach (schwebend) bereit: signal | + | |
- | laufend nach blockiert: wait | + | |
- | Mittelfristige Planung: | + | #include < |
- | | + | #include < |
- | + | #include < | |
- | | + | #include < |
- | | + | #include < |
- | | + | #include < |
- | | + | #include < |
- | | + | #include < |
- | + | #include < | |
- | Langfristig: | + | |
- | gestoppt, erzeugt, beendet | + | |
- | Mittelfristig: | + | |
- | schwebend bereit, schwebend blockiert (aka ausgelagert) | + | |
- | Kurzfristig: | + | |
- | blockiert, bereit, laufend | + | |
- | | + | |
- | b) | + | // weitere Includes, Konstanten |
+ | // globale Variablen, Funktionsdeklarationen usw. | ||
- | Einplanung: (schwebend) blockiert nach bereit | + | #define BUFFER_SIZE 64 |
- | Umplanung: Prozess wird verdrängt oder gibt CPU freiwillig ab (relinquish) --> direkt von laufend nach bereit | + | |
- | Anm: Einlasten (dispatching, | + | |
- | c) | + | unsigned int spawnThreads(void); |
+ | void *feedPrinter(const char*); | ||
+ | SEM *semCreate(int); | ||
+ | void P(SEM *); | ||
+ | void V(SEM *); | ||
- | kooperativ | + | struct SEM { |
- | - Prozesse geben freiwillig ab [oder wird im Rahmen eines von ihm getätigten Systemaufrufs | + | volatile int val; |
- | - Prozesse können CPU monopolisieren | + | pthread_mutex_t m; |
- | - FCFS, zB sehr kurz laufende Prozesse | + | pthread_cond_t c; |
+ | }; | ||
- | präemptiv | + | static int port; |
- | - Prozesse werden verdrängt | + | static int buffer[BUFFER_SIZE]; |
- | - Typisch mehr Mehrbenutzer/ | + | static int in, out; |
- | - RoundRobin, Feedback, Virtual Round Robin ist auch präemtiv | + | static SEM *inSem, *outSem; |
- | d) | + | static void die(const char message[]) { |
+ | perror(message); | ||
+ | exit(EXIT_FAILURE); | ||
+ | } | ||
- | nur laufend -> bereit | + | int main(int argc, char *argv[]) { |
- | präemptiv: gewaltvoll | + | unsigned int printer; |
- | kooperativ: freiwillig | + | int sock; |
+ | struct sockaddr_in6 addr; | ||
- | ==== Aufgabe 4: ==== | + | if (argv != 2) { |
+ | fprintf(stderr, | ||
+ | return 0; | ||
+ | } | ||
+ | |||
+ | if ((inSem | ||
+ | die(" | ||
+ | |||
+ | if ((outSem = semCreate(0)) == NULL) | ||
+ | die(" | ||
+ | |||
+ | port = (int) strtol(argv[1]); | ||
+ | |||
+ | printer = spawnThreads(); | ||
+ | if (printer < 0) | ||
+ | die(" | ||
+ | |||
+ | printf(" | ||
+ | if (printer == 0) | ||
+ | return 0; | ||
+ | |||
+ | sock = socket(AF_INET6, | ||
+ | if (sock < 0) | ||
+ | die(" | ||
+ | |||
+ | addr = { | ||
+ | .sin6_family = AF_INET6, | ||
+ | .sin6_port = htons(port), | ||
+ | .sin6_addr = in6addr_any, | ||
+ | }; | ||
+ | |||
+ | if (bind(sock, (struct sockaddr *) &addr, sizeof(addr)) != 0) | ||
+ | die(" | ||
+ | if (listen(sock, | ||
+ | die(" | ||
+ | |||
+ | for (;;) { | ||
+ | int clientSock | ||
+ | if (clientSock < 0) | ||
+ | continue; | ||
+ | P(inSem); | ||
+ | buffer[in] | ||
+ | in = (in + 1) % BUFFER_SIZE | ||
+ | V(outSem); | ||
+ | } | ||
+ | close(sock); | ||
+ | return 0; | ||
+ | } | ||
- | a) | + | unsigned int spawnThreads() { |
+ | unsigned int numb; | ||
+ | DIR *dir = opendir("/ | ||
+ | if (dir == NULL) | ||
+ | return numb; | ||
+ | struct dirent *ent; | ||
+ | while (errno = 0, (ent = readdir(dir)) != NULL) { | ||
+ | if (ent-> | ||
+ | char path[6 + strlen(ent-> | ||
+ | snprintf(path, | ||
+ | struct stat s; | ||
+ | if (lstat(path, | ||
+ | return 0; | ||
+ | if (S_ISREG(s.st_mode)) { | ||
+ | if (pthread_create(NULL, | ||
+ | return 0; | ||
+ | numb++; | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | if (errno != 0) | ||
+ | return 0; | ||
+ | return numb; | ||
+ | } | ||
- | Durch die MMU, bei der Umrechnung der virtuellen Adress, durch das Present-Bit | + | void *feedPrinter(const char device[]) { |
+ | FILE *dev = fopen(device, " | ||
+ | if (dev == NULL) { | ||
+ | return; | ||
+ | } | ||
+ | for (;;) { | ||
+ | int sock; | ||
+ | P(outSem); | ||
+ | do { | ||
+ | sock = buffer[out]; | ||
+ | out = (out + 1) % BUFFER_SIZE; | ||
+ | } while (__sync_compare_and_swap(buffer[out], | ||
+ | V(inSem); | ||
+ | FILE *req; | ||
+ | if ((req = fdopen(sock, | ||
+ | continue; | ||
+ | int c; | ||
+ | while ((c = fgetc(req)) != EOF) | ||
+ | fputc(c, dev); | ||
+ | close(sock); | ||
+ | } | ||
+ | } | ||
- | b) (das muss man tatsaechlich so aufdroeseln um 8/8 zu bekommen) | + | SEM *semCreate(int initial_value) { |
+ | struct SEM sem = { | ||
+ | .val = initial_value | ||
+ | } | ||
+ | errno = 0; | ||
+ | if ((errno = pthread_mutex_init(sem.m, | ||
+ | return NULL; | ||
+ | if ((errno = pthread_cond_init(sem.c, | ||
+ | return NULL; | ||
+ | return &sem; | ||
+ | } | ||
- | 1. MMU loest Trap (nicht Interrupt?) aus | + | void P(SEM *sem) { |
- | 2. BS loest Handler fuer Pagefault aus | + | if ((errno = pthread_mutex_lock(& |
- | 3. freier Platz wird im Hauptspeicher gesucht ggf. andere Seite auslagern | + | return; |
- | 4. Einlagerung von Platte angestossen | + | while (sem-> |
- | 5. Prozess wird blockiert bist Einlagerung fertig ist | + | if ((errno = pthread_cond_wait(& |
- | 6. Interrupt | + | pthread_mutex_unlock(& |
- | 7. Present-Bit wird auf 1 gesetzt | + | return; |
- | 8. Prozess geht in Zustand bereit ueber | + | } |
- | 9. Befehl der den Trap ausgeloest hat wird wiederholt | + | } |
+ | sem->val-- | ||
+ | if ((errno = pthread_mutex_unlock(& | ||
+ | return; | ||
+ | } | ||
+ | void V(SEM *sem) { | ||
+ | if ((errno = pthread_mutex_lock(& | ||
+ | return; | ||
+ | sem-> | ||
+ | if ((errno = pthread_cond_broadcast(& | ||
+ | return; | ||
+ | if ((errno = pthread_mutex_unlock(& | ||
+ | return; | ||
+ | } | ||
+ | </ |