Quelle est la meilleure façon d'exécuter des tâches en parallèle dans Ksh et Perl?

Question

J'ai ce grand projet C ++ que je dois construire sur une plate-forme qui n'a pas de marque parallèle (comme make -j sur Linux). Le serveur a 6 CPU et je veux faire une construction parallèle manuellement.

Je peux générer une liste de tâches comme celle-ci pour environ 300 fichiers objets. J'utilise le Makefile pour les vérifications de dépendance et la construction incrémentielle:

make -f Makefile obj1.o

make -f Makefile obj2.o

make -f Makefile obj3.o ...

Comment pourrais-je exécuter ces tâches en parallèle avec pas plus de 6 tâches exécutées simultanément à l'aide de Ksh et de Perl? (Java ou Python ne sont pas disponibles :-()

Answer 1

En Perl, consultez Parallel :: ForkManager . Vous pouvez faire quelque chose comme ça:

my @make_obj = qw(
  obj1.o
  obj2.o
  obj3.o
  ...
);

my $fm = $pm = new Parallel::ForkManager(6);
foreach my $obj (@make_obj) {
  $fm->start and next;
  system("make -f Makefile $make_obj");
  $fm->finish();
}

Answer 2

Une alternative au forgeage consiste à exécuter chaque marque dans son propre thread.

use threads;

my $max_threads = 5;

my @targets = qw(obj1.o obj2.o obj3.o ...);
while(@targets) {
    my $num_threads = threads->list(threads::running);
    if( $num_threads < $max_threads ) {
        my $target = shift @targets;
        threads->create(sub { return system "make $target" });
    }
}

Je suis malheureusement agitant la main autour de deux bits. La première consiste à faire attendre la boucle jusqu'à ce qu'un thread se termine. Je crois que cela est accompli en utilisant cond_wait () de threads :: shared et une variable sémaphore.

La seconde consiste à obtenir la valeur de retour de make, vous permettant ainsi de savoir si quelque chose a échoué et d’interrompre la construction. Pour ce faire, vous devez rejoindre () chaque thread pour obtenir le résultat de system (), le code de sortie du processus.

Désolé pour la réponse précipitée. Espérons que la communauté remplira le reste.

Answer 3

Est-ce que gnu fait sur HPUX pas le drapeau -j?

http://hpux.connect.org.uk/ hppd / hpux / Gnu / make-3.81 /

Answer 4

En utilisant GNU Parallel, vous pouvez écrire:

parallel -j6 make -f Makefile obj{}.o ::: {1..500}

10 secondes d'installation:

(wget -O - pi.dk/3 || curl pi.dk/3/ || fetch -o - http://pi.dk/3) | bash

En savoir plus: http://www.gnu.org/software/parallel/parallel_tutorial .html https://www.youtube.com/playlist?list=PL284C9FF2488BC6D1

Answer 5

Si le système d'exploitation gère correctement la communication et la planification entre les processeurs, vous devriez simplement pouvoir intégrer toutes les marques dans des processus en arrière-plan, à condition qu'il n'y ait pas d'interdépendance.

S'ils sont tous indépendants, j'émettrais une série de commandes comme celle-ci:

make -f Makefile obj1.o &
make -f Makefile obj2.o &
...
make -f Makefile objn.o &

Avec les dépendances, enchaînez-les avec l'esperluette double ( & amp; & amp; ) afin que l'élément dépendant ne commence pas tant que son "parent" n'est pas terminé.

Je réalise que ce n’est pas tout à fait la solution que vous avez demandée, mais c’est de cette façon que j’attaquerais le problème:)