[C/C++] Linux - Prozessprogrammierung

Dieses Thema im Forum "Programmierung & Entwicklung" wurde erstellt von DeLiCioUz, 22. Oktober 2010 .

Schlagworte:
  1. 22. Oktober 2010
    Zuletzt von einem Moderator bearbeitet: 14. April 2017
    Linux - Prozessprogrammierung

    Neue Frage im Post unten

    ------------------------------------

    Hallo,

    bin noch ziemlich neu in der Materie und hab hier eine ziemlich knifflige Aufgabe, bei der ich keinen richtigen Ansatz finde. Mir gehts erstmal nur grundsätzlich um die Struktur, den Rest kann man ja fix einbauen wenns erstmal steht.
    Spoiler
    Bild

    In der Aufgabe davor war dieser Code gegeben:
    Code:
    #include <sys/types.h>
    #include <unistd.h>
    #include <stdio.h>
    #include <stdlib.h>
    
    int main() {
     int i;
     for( i = 0; i < 3; i++ ) {
     if( fork() == 0 ) {
     printf("Kind: PID: %d; PPID: %d\n", getpid(), getppid() );
     }
     }
     sleep(1);
     int status;
     wait(&status);
     printf("... und tschüss.\n");
    }
    
    Die erzeugte Struktur sieht dann so aus, ist also unbalanciert mit größerer Tiefe in den Linken Teilbäumen:
    Spoiler
    Bild

    Ich hab keine Ahnung wie ich so eine Prozessstruktur mit fork() erstellen könnte...theoretisch müsste man ja zwischen den Prozessen hin und her wechseln und dann dementsprechend die Kindprozesse erzeugen, da es ja sonst immer zu solchen Bäumen wie in dem Bild kommt. Seit Stunden suche ich jetzt schon vergeblich nach einer Lösung, ich hoffe hier kann mir jemand helfen.

    MfG
     
  2. 22. Oktober 2010
    AW: Linux - Prozessprogrammierung

    Recht simpel. fork() erstellt eine exakte Kopie des Prozesses, d.h. du könntest einen Baum erstellen, wo sich die Kinder eintragen und sich daran auch identifizieren (1. Generation, 2. Generation, n. Generation) und ihre Arbeit verrichten.
     
  3. 22. Oktober 2010
    AW: Linux - Prozessprogrammierung

    Ist das echt so simpel? Ich steh glaub ich ziemlich aufm Schlauch...

    Wenn ich zb von der Wurzel abgehend 3 Kinder haben möchte, muss ich 3 mal durch eine Schleife iterieren in der Kindprozesse erzeugt werden, was bedeutet, dass diese Kinder auch wieder Kinder erzeugen, usw. und damit wirds dann unausgeglichen. Daher versteh ich nicht wie ich das mit nem Baum umsetzen könnte, es ist ja auch nicht möglich den Eltern manuell Kindprozesse zuzuordnen.
     
  4. 23. Oktober 2010
    AW: Linux - Prozessprogrammierung

    Du brauchst zuallererst eine Tabelle mit Beschreibungen ala Generation und die Anzahl Kinder, also die nächste Generation.

    Code:
    unsigned int uiGenTable[] = {4, 2, 1, 0};
    Hier soll nun die 1. Generation 4 Kinder, die 2. 2 Kinder, usw. haben bis keine Kinder mehr erwünscht sind. Nun erstellst du einen Pseudobaum, wo sich die Generationen auflisten.

    Code:
    struct Process {
     unsigned int uiGen;
     struct Process *spPChildren,
     *spPParent;
     unsigned char bUsed; // Zur Erfassung, ob von Generation x Kind y schon erkannt
    };
    
    struct Process sPRoot = {0, NULL, 1}; // 1. Generation, Startknoten
    
    void createNextGeneration( struct Process *spPGen ); // Mir fällt grad kein besserer Name ein^^
    struc Process* getCurrentGeneration( struct Process *spPFirst );
    createNextGeneration() würde nun die Kinder anhand der Generationstabelle erstellen und getCurrentGeneration() gibt ein Kind der jetzigen Generation wieder, welches mit unserer Variable bUsed möglich wird (1 == Benutzt, ein anderer Wert == Unbenutzt, also ist der aktuelle Prozess wohl das Kind y aus Generation x).
     
  5. 24. Oktober 2010
    AW: Linux - Prozessprogrammierung

    Vielen Dank für die Mühen, ich kann auf jeden Fall nachvollziehen was deine Idee dahinter ist. Den Aufbau mit den structs hatte ich mir so inetwa gedacht nach deinem 1. Post, aber ich verstehe immer noch nicht wie ich dann mit fork() die Prozesse in der richtigen Hierarchie erstellen kann... Nach jedem fork() wird vom aufrufenden Prozess ein Kindprozess erstellt, von dem aus alles weitere passiert, der Elternprozess steht unwiderruflich fest. In einer Schleife führt fork() immer(?) zu einem Baum, der in den linken Teilbäumen tiefer ist. Genau dieses Muster hab ich irgendwie immer im Kopf...wahrscheinlich habe ich nen Denkfehler drin. Dazu kommt dass mein C ziemlich eingerostet ist ^^

    Habe morgen Praxis und da bei uns alle Probleme mit der Aufgabe haben, werden wir wahrscheinlich ein paar Tipps bekommen. Werd mich dann morgen nochmal dransetzen und Ergebnisse hier posten.
     
  6. 24. Oktober 2010
    AW: Linux - Prozessprogrammierung

    Naja. fork() kopiert den kompletten Prozess, d.h. der Baum bleibt erhalten, und durch getCurrentGeneration() bekommst Du den jeweiligen Knoten für den aktuellen Prozess.
     
  7. 27. Oktober 2010
    AW: Linux - Prozessprogrammierung

    So, habens dann schließlich doch noch hinbekommen ^^ man musste einfach die process-id´s zwischenspeichern und dann, wenn man sich im Vaterprozess befindet, weitere Prozesse erstellen...sagt sich so leicht, muss man aber auch erstmal drauf kommen

    Danke trotzdem terraNova für die Hilfe!

    Code:
    // myfamily.c (aka bsp7a.c )
    #include <sys/types.h>
    #include <unistd.h>
    #include <stdio.h>
    #include <stdlib.h>
    
    int main() {
     int i,j;
     pid_t a,b,c;
     a = getpid();
     printf("1.Gen - Process = %d waiting for my children to complete\n",getpid());
     sleep(2);
     for( i = 0; i < 4; i++ ) {
     if (a == getpid()){
     if( fork() == 0 ) {
     printf("2.Gen - Process = %d Parent = %d waiting for my children to complete\n",getpid(),getppid());
     //******************************************************************************************
     sleep(2);
     b=getpid();
     for(j = 0; j < 2; j++){
     if (b== getpid()){
     if(fork()==0){
     printf("3.Gen - Process = %d Parent = %d waiting for my children to complete\n", getpid(), getppid() ); 
     //------------------------------------------------------------------------------------
     sleep(2);
     if(fork()==0){
     printf("4.Gen - Process = %d Parent = %d waiting for my children to complete\n", getpid(), getppid() );
     }
     //------------------------------------------------------------------------------------ 
     }
     }
     else break;
     }
     //******************************************************************************************
     }
     }
     else break;
     }
     sleep(5);
     int status;
     wait(&status);
     printf("I,m process %d and I'm done.\n",getpid());
    }
    
     
    
     
  8. 19. November 2010
    AW: Linux - Prozessprogrammierung

    Ich stell die Frage mal hier, da es fast das selbe Thema betrifft.

    Wir müssen nun die selbe Hierarchie wie im Startpost mit Posix-Threads programmieren. Dass wir nicht gleich structs genommen haben, wie terraNova das vorgeschlagen hat, war nicht sehr schlau weil wir die jetzt sowieso brauchen *g

    Naja, habe eigentlich nur ne Verständnisfrage zu der Formel in der neuen Aufgabe:

    Code:
    Die Anzahl der erzeugten Threads berechne sich nach 
    o N = min ( (floor(A/B), 16), wobei 
     - A: Per Parameter von der Elterngeneration an jeden Thread 
     übergebener Wert N der Anzahl vom Elternthread erzeugten Threads 
     - B: Divisor, als globale Variable gegeben (in 2-4. War dies 2). 
    floor(x/y) heißt ja sowas wie abrunden, also sollte bei int-Werten 7/3 = 2 herauskommen. min(x, y) gibt wenn ich das richtig verstehe den kleineren der beiden Parameter zurück, also min(3, 5) = 3. Ist das soweit richtig? Aber warum soll dann 16 die Obergrenze sein, wenn doch laut Bild 20 Threads erzeugt werden müssen?
     
  9. 20. November 2010
    AW: Linux - Prozessprogrammierung

    Zur 1. Frage: Ja.

    Zur Andere: 2^4 ist wesentlich schöner aufzuteilen als eine willkürliche Zahl wie 20. Aber wieso fragst Du nicht deinen Prof., der wird es doch am ehesten wissen!? ;-)
     
  10. 20. November 2010
    AW: Linux - Prozessprogrammierung

    Weil ich die Aufgabe ziemlich verpennt hab und das Montag abgeben muss ^^ Programm läuft zwar, hoffe mal dass ich die Formel nicht erklären muss :/

    Ich vermute, dass die ersten 4 Threads per Define/Parameter übergeben werden und sich die folgenden dann durch die Formel berechnen...so hab ichs jetzt zumindest gemacht. Naja, schaun mer mal
     
  11. 11. April 2013
    AW: Linux - Prozessprogrammierung

    hallo,
    ich brauch hilfe bei diese aufgabe

    Die Prozessfamilie myfamily.c
    a. Problemanalyse
    • Betrachten Sie das unten angegebene Programm myfamily.c und analysieren Sie
    sein Verhalten ohne es zu übersetzten und auszuführen.
    • Stellen Sie die Struktur der Prozessfamilie graphisch dar und zeigen Sie Ihre Lösung
    im Praktikum.

    int main() {
    int i;
    for( i = 0; i < 3; i++ ) {
    if( fork() == 0 ) {
    printf("Kind: PID: %d; PPID: %d\n",
    getpid(), getppid() );
    }
    }
    sleep(1);
    int status;
    wait(&status);
    printf("... und tschüss.\n");


    ich weiss nicht wie ich das Verhalten beschreiben soll!
     
  12. Video Script

    Videos zum Themenbereich

    * gefundene Videos auf YouTube, anhand der Überschrift.