Faire des enfants processus d'attente jusqu'à réception du parent signal

Je veux créer des N les enfants d'un parent. Je veux que tous les enfants de départ (une fonction de mesure du temps) en même temps. Alors j'ai mis la fonction dans un gestionnaire de signal et lorsque le parent terminer la création (fourche) tous les enfants, il envoie le signal (à l'aide de tuer(children_id)) à tous les enfants à laisser faire démarrer. Le code est ci-dessous, mais il ne fonctionne pas comme prévu. Plus précisément, il fourchue tous les enfants, mais ne les exécute pas la fonction "measure_time". Cette fonction n'est pas la chose, mais d'enregistrer des temps d'exécution et à imprimer.
Quelqu'un pourrait-il me faire savoir si je fais quelque chose de mal?

    int n_task = 4;
    for (i = 0; i < n_task; i++){
            pid = fork();
            if (pid < 0){
                    printf("cannot fork!\n");
            } else
            if (pid == 0){ //child
                    printf("printed from child [%d]\n", getpid());                        
                    signal(SIGUSR1, measure_time); //measure_time is a function
                    exit(0);
            } else {
                    pid_array[i] = pid;
            }
    }

    //This code is executed from parent only
    for (int i = 0; i < n_task; i++)
    {
            kill(pid_array[i], SIGUSR1);                
    }
Une raison pour laquelle vous êtes à l'aide de fork() et pas pthreads?
c'est un exercice qui nécessite l'utilisation de fork() et signal() ou sigaction() et kill()? Probablement la raison suffisante.
Ouais je suis juste en train de jouer avec fork().

OriginalL'auteur Zk1001 | 2013-11-10

  1. 7
    if (pid == 0){ //child
    printf("printed from child [%d]\n", getpid());                        
    signal(SIGUSR1, measure_time); //measure_time is a function
    exit(0);
}

    Les enfants se créé, configurer le gestionnaire, et immédiatement à la sortie (c'est à dire mourir). Font dormir ou de bloquer sur quelque chose de si il est effectivement temps pour les parents de distribuer les signaux.

    Mise à jour

    #define _POSIX_SOURCE

#include <stdio.h>
#include <errno.h>
#include <unistd.h>
#include <signal.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>   

void measure_time(int sig)
{
    printf("child [%d] received signal %d\n", getpid(), sig);
}

int main(int argc, char *argv[])
{
    int n_task = 4;

    pid_t pid;
    pid_t pid_array[n_task];

    for (int i = 0; i < n_task; i++)
    {
        pid = fork();

        if (pid < 0)
        {
            perror("fork");
            exit(1);
        }

        if (pid == 0) //child
        {
            printf("printed from child [%d]\n", getpid());
            signal(SIGUSR1, measure_time); //measure_time is a function
            sleep(5);

            exit(0);
        }

        //parent
         pid_array[i] = pid;
    }    

    //This code is executed from parent only
    sleep(1);

    for (int i = 0; i < n_task; i++)
        kill(pid_array[i], SIGUSR1);

    for (int i = 0; i < n_task; i++)
        wait(NULL);    

    return (0);
}

    Tous les processus et les threads sont soumis aux caprices de l'OS du planificateur. Dans votre code initial les enfants et le parent peut potentiellement mettre fin avant la séquence des événements que vous espérez prendre place peut se produit jamais. Les enfants peuvent mourir avant que le parent jamais envoie un signal; le parent peut envoyer ses signaux avant que les enfants n'avaient mis en place leur maître (et SIGUSR1 tuer le processus parce que c'est son défaut en l'absence d'un gestionnaire). Il y a si peu de code à exécuter tout cela se fait en quelques millisecondes, soit moins que le temps que l'un de ces processus obtient à planifié pour s'exécuter (et donc de mettre en place suffisamment pour répondre à votre expections). J'ai ajouté quelques sleep à tout donner un peu de répit et un wait de sorte que le parent ne veut pas mourir. Cela devrait vous permettre de voir comment il fonctionne.

    Le pause() de la fonction est le classique et le plus simple d'attendre un signal pour arriver. Il ne revient jamais normalement; il ne retourne jamais quand un signal interrompt.
    Essayé votre code. Mais il ne fait pas tous les 4 missions en même temps. Pour être plus précis, j'ai ajouté du sommeil(1) dans measure_time(). Les enfants imprimer leur "signal reçu" sur une base de 1 seconde. Pourriez-vous essayer encore une fois?
    J'ai édité le parent de tuer/code d'attente en 2 boucles. Peut-être que c'est ce que vous avez été voir. Mes excuses pour le court avec vous. Même pas fini avec mon café du matin.

    OriginalL'auteur Duck

  2. 1
    if (pid == 0){ //child
    printf("printed from child [%d]\n", getpid());                        
    signal(SIGUSR1, measure_time); //measure_time is a function
    pause();
    exit(0);
}

    Je pense que le problème est, les enfants sont les Processus mis fin immédiatement après qu'ils ont créé. donc

    Utilisation pause() fonction d'attendre le signal pour arriver.

    Et si certains Processus enfants ne réagissent pas comme prévu, essayez ce aussi.

    for (j = 0; j < n_task; j++)
    {
            kill(pid_array[j], SIGUSR1); 
            sleep(1);
    }
    c'est un peu comme le Canard de réponse donc je vais commenter ici. J'ai essayé cela, mais parmi les 4 threads créés, seulement 1 (parfois) 2 fils sont exécutés. Est-il encore quelque chose qui manque?
    for (j = 0; j < n_task; j++) { tuer(pid_array[j], SIGUSR1); sleep(1); } essayer de cette façon, ça marchera. ( je ne sais pas exactement pourquoi cela se produise, mais je pense que c'est parce que le processus parent d'envoyer le signal, avant que certains des enfants les Processus d'installer le gestionnaire de signal.)
    Mais ce ne sera pas vous aider à atteindre votre but, pour commencer (une fonction de mesure du temps) en même temps, de tous les enfants. Mais tous les Processus enfants seront exécutées.
    Oui, il fonctionne comme vous le pensiez. Grand. Mais ensuite, j'ai pour retarder le signal envoie! Ce n'est pas ce que je voulais. Je veux envoyer le signal, pour être plus précis, broatcast, à tous les enfants et de les laisser commencer en même temps, plus ou moins. Quelqu'un pourrait donner une indication?
    Êtes-vous les gars pour de vrai? un Peu similaire?

    OriginalL'auteur Deadlock