oeztuerk_42
Anmeldungsdatum: 19. Mai 2019
Beiträge: 25
|
Ich habe die Aufgabe zu ermitteln warum nach Beendigung des Programms der Inhalt *shared_mem des geteilten Speichers größer sein kann als MAX_COUNT und warum ist die Anzahl der insgesamt durchgeführten Zahlvorgänge größer als MAX_COUNT?
Ich komme nicht weiter finde die Antwort dafür nicht.
Hoffe mir kann jemand weiterhelfen. 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63 | Code
#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#define MAX_COUNT ( 1000000000L)
#define NUM_CHILDREN (20)
#define SHMSEGSIZE sizeof(long)
int main()
{
long i; // Zaehlvariable fuer Schleifen
int shmID; // id (Schluessel) des shared memory Segmentes
long *shared_mem; //Zeiger auf den Speicherbereich, in den das shared memory "eingehaengt" wurde.
long count; // Zaehlt Schleifendurchlaeufe
int pid[NUM_CHILDREN]; // Speichert die Prozess-IDs der Kindprozesse
shmID=shmget(IPC_PRIVATE, SHMSEGSIZE, IPC_CREAT | 0644); // IPC_PRIVATE laesst den Kern den Schluessel erzeugen
shared_mem=(long *)shmat(shmID,0,0);
*shared_mem = 0;
count=0L;
// Erzeugen der Kindprozesse
for (i=0; i< NUM_CHILDREN; i++)
{
pid[i]=fork();
if (pid[i] < 0) // Fehlerfall
{
printf("Kindprozess nicht erzeugbar!\n");
return (0);
}
else
{
if (pid[i] == 0) // Dies ist das Kind
{
while (*shared_mem < MAX_COUNT)
{
*shared_mem +=1; // Jedes Kind arbeitet auf derselben shared_mem Variable
count++; // Jedes Kind hat eigene count-Variable
if ((count % 10000000 ) == 0)
printf("%ld-tes Kind, count %ld\n",i, count);
}
printf("%ld-tes Kind erhoehte den Wert um %ld!\n",i,count);
shmdt(shared_mem);
return 0;
}
}
}
// Dies ist der Vaterprozess
for (i=0; i< NUM_CHILDREN; i++)
waitpid(pid[i], NULL,0);
printf("Shared Memory M = %ld : MAXCOUNT = %ld\n", *shared_mem, MAX_COUNT);
shmdt(shared_mem);
shmctl(shmID, IPC_RMID,0);
return (0);
}
|
|
ChickenLipsRfun2eat
Anmeldungsdatum: 6. Dezember 2009
Beiträge: 12067
|
oeztuerk_42 schrieb: Ich habe die Aufgabe zu ermitteln warum nach Beendigung des Programms der Inhalt *shared_mem des geteilten Speichers größer sein kann als MAX_COUNT und warum ist die Anzahl der insgesamt durchgeführten Zahlvorgänge größer als MAX_COUNT?
Ich versuche es mal mit Gegenfragen:
Worauf verweist der Zeiger *shared_mem? Wie ist MAX_COUNT definiert? An welchen Stellen werden Variablen verwendet? An welchen Stellen werden Variablen erhöht? An welchen Stellen wird mit Variablen gerechnet? An welchen Stellen werden die Variablen geprüft?
|
oeztuerk_42
(Themenstarter)
Anmeldungsdatum: 19. Mai 2019
Beiträge: 25
|
Tut mir leid aber viel dazu kann ich Leider nicht sagen, weil deine Fragen ja im code Stehen. So gut bin ich leider in diesem Bereich auch nicht um dir deine Fragen zu beantworten ☹
|
Cranvil
Anmeldungsdatum: 9. März 2019
Beiträge: 990
|
Ich glaube, ChickenLipsRfun2eat hat mit seinen Fragen versucht, dir einen Ansatz zu geben, damit er nicht darauf hinweisen muss, dass hier ungern die Hausaufgaben anderer ohne deren Mitwirkung gelöst werden. Versuche doch tatsächlich mal, Antworten auf die Fragen zu finden. Wenn dir etwas unklar ist, stelle Vermutungen an oder stelle konkretere Fragen. Ich finde es gerade in Foren wie diesem hier schade, wenn jemand die Sachen reinwirft und jegliche Annäherung an weitere Erkenntnisse mit dem Hinweis abblockt, dass da kein Wissen da ist. Jeder hier hat das alles mal nicht gewusst. 😉
|
oeztuerk_42
(Themenstarter)
Anmeldungsdatum: 19. Mai 2019
Beiträge: 25
|
Mein Ziel ist es nicht das hier jemand meine hauszafgaben macht. Nur die Frage vom Kollegen war für mich unklar weil es ja im Code steht. -An welchen Stellen werden Variablen verwendet?
-An welchen Stellen werden Variablen erhöht?
.
.
.
Für die anderen Fragen gilt das selbe. Ich habs versucht sonst wäre ich nicht hier. Wenn duCranvil mir weiterhelfen willst wäre ich dankbar wen nicht brauchst du solche Kommentare nicht rausgeben.
Vielen Dank ☺
|
radoe2
Anmeldungsdatum: 30. November 2006
Beiträge: 243
|
Ich geb dir mal noch ein paar Tipps:
Nimm mal an, im SHM steht gerade schon der Wert MAXCOUNT-1 Was passiert wenn z.B. ein Prozess gerade den Code in Zeile 41 abarbeitet, ein oder mehrere der anderen aber schon etwas weiter sind und gerade den Code in Zeile 43 ausführen werden? Dann betrachte die Reihenfolge auch noch einmal genau anders run...
Deine Stichworte zum Verstehen und korrigieren sind etwas wie "Nebenläufigkeit und gegenseitiger Ausschluß", "Critical Section", "Mutex", "Atomares Read-Modify-Write" oder ähnliche theoretische Grundlagen. BTW - fehlt da nicht auch noch ein volatile?
|
ChickenLipsRfun2eat
Anmeldungsdatum: 6. Dezember 2009
Beiträge: 12067
|
Cranvil schrieb: Ich glaube, ChickenLipsRfun2eat hat mit seinen Fragen versucht, dir einen Ansatz zu geben, damit er nicht darauf hinweisen muss, dass hier ungern die Hausaufgaben anderer ohne deren Mitwirkung gelöst werden.
Korrekt. Hat er versucht 😀 Versuch es doch mal mit ein paar "Debug"-Ausgaben, wie bspw: 1
2
3
4
5
6
7
8
9
10
11
12
13 | for (i=0; i< NUM_CHILDREN; i++)
{
printf("::::Wir bearbeiten gerade Kindprozess:%ld\n",i);
pid[i]=fork();
if (pid[i] < 0) // Fehlerfall
{
printf("Kindprozess nicht erzeugbar!\n");
return (0);
}
else
{
printf("::::Hier geht es im erstellten Kind %ld weiter.",i);
…
|
|
oeztuerk_42
(Themenstarter)
Anmeldungsdatum: 19. Mai 2019
Beiträge: 25
|
radoe2 schrieb: Ich geb dir mal noch ein paar Tipps:
Nimm mal an, im SHM steht gerade schon der Wert MAXCOUNT-1 Was passiert wenn z.B. ein Prozess gerade den Code in Zeile 41 abarbeitet, ein oder mehrere der anderen aber schon etwas weiter sind und gerade den Code in Zeile 43 ausführen werden?
Danke für dein Tipp, eine Frage habe ich dazu.
Laufen die Prozesse dann Parallel ab? Weil wenn die 20 Kind Prozesse nach der Reihe laufen würden dürfte ja kein Problem entstehen.
|
oeztuerk_42
(Themenstarter)
Anmeldungsdatum: 19. Mai 2019
Beiträge: 25
|
ChickenLipsRfun2eat schrieb:
Versuch es doch mal mit ein paar "Debug"-Ausgaben, wie bspw: 1
2
3
4
5
6
7
8
9
10
11
12
13 | for (i=0; i< NUM_CHILDREN; i++)
{
printf("::::Wir bearbeiten gerade Kindprozess:%ld\n",i);
pid[i]=fork();
if (pid[i] < 0) // Fehlerfall
{
printf("Kindprozess nicht erzeugbar!\n");
return (0);
}
else
{
printf("::::Hier geht es im erstellten Kind %ld weiter.",i);
…
|
Ja Danke das werde ich gleich ausprobieren ☺
|
oeztuerk_42
(Themenstarter)
Anmeldungsdatum: 19. Mai 2019
Beiträge: 25
|
radoe2
Wollte Fragen ob ich das jetzt richtig verstanden habe, weil muss Donnerstag mein Wissen abgeben. Also da die Prozesse parallel laufen kann es dazu führen das shared_mem hochgezählt wird während ein andere Prozess bei der zeile 41 ist. Das führt dann dazu das der Speicher schon voll ist also dass shared_mem bei 1000000000 ist aber weil ein anderer Prozess sich bei der Zeile 43 befindet wird shared_mem trodzdem nocheinmal hochgezählt. Hoffe das ich es richtig verstanden hab ☺!
|