Forum Linux.général Logiciel de Batch tout simple

Posté par (page perso) .
Tags : aucun
1
27
jan.
2010
Bonjour à tous,

je suis à la recherche d'un logiciel permetant de gérer une liste de commande à lancer sur une machine et qui s'arrange pour les lancer en séquence. Un petit truc du style de ce que l'on installe sur un cluster mais en tout simple.

Je m'explique un peu plus clairement. J'ai un peu plus de 400 commandes à lancer qui prennent un temps variable, entre une heure et une centaine d'heures. Je dispose d'une machine à quatre processeurs bi-cœurs, donc je peut lancer jusqu'a 8 commandes en même temps.

Ce que je souhaite, c'est un programme à qui je donne la liste et le nombre de commandes simultannée (ici 8) et qui va lancer les N premiére et attendre. Dès qu'une des commandes ce termine, il lance la suivante de manière à ce qu'il y en ai toujours N en cours.

Ces ce que font les outils pour clusters mais ils sont particuliérement lourd à lancer et font un peu office de tronçoneuse pour tuer une mouche dans le cas qui m'intéresse.

Avez vous des idées ?
Merci
  • # man taskset

    Posté par . Évalué à 1.

    taskset - retrieve or set a process's CPU affinity
    • [^] # Re: man taskset

      Posté par (page perso) . Évalué à 1.

      Merci, mais ce n'est pas du tout ce que je cherche. Taskset te permet de chosir sur quel cpu executer une tache mais il ne va pas ce charger tout seul de lancer des commandes.

      Je me tape de savoir sur quel proc la commande est executée. Linux fait tres bien sont boulot a ce niveau. Si je lance 8 commandes en même temps, les 8 proc seront utiliser en même temps.

      Le problemes c'est que j'ai 400 commandes a lancer, et que je ne peut les lancer que 8 à la fois. Tout ce qu'il me faut c'est un programme qui surveille ces 8 programme et qui, quand un ce termine, lance le suivant.
      • [^] # Re: man taskset

        Posté par . Évalué à 2.

        tu as tout a fait raison, il reste bien du travail. Peut-etre a combiner avec des scripts de ton invention (shell, perl, php, python), ou les astuces citées sur cette page.
        • [^] # Re: man taskset

          Posté par (page perso) . Évalué à 2.

          C'est plus que il reste bien du travail puisque ce que fait la commande c'est spécifier qu'un programme doit s'éxecuter sur un processeur particulier alors que dans mon cas le noyeau ce débrouille trés bien tout seul si on le laisse faire...
  • # sh ?

    Posté par . Évalué à 4.

    je n'ai pas d'outil tout fait en tête, mais ce ne me semble pas difficile à faire dans un script shell prenant en premier argument un fichier avec la liste de tes commandes et en deuxième le nombre de commandes à lancer en simultanée. Ensuite:

    charger le fichier dans un tableau commands
    running_command=0
    while 1 do
    .......if runnning_command=0 then exit fi
    .......while running_command<$2 do
    ..........command=shift commands
    ..........lancer commande en tache de fond
    ..........recupérer le pid et le placer dans un tableau pids
    .......done
    .......foreach pids as pid do
    ..........if ps|grep pid != pid then
    ..............running_command--
    ..........fi
    .......done
    .......sleep 5
    done


    c'est un pseudo code goret mais ça me semble correspondre à ce que tu demandes non ?
    • [^] # Re: sh ?

      Posté par . Évalué à 1.

      en oubliant pas d'incrémenter ton running_command à chaque lancement de commandes et en gérant la sortie de ton script différemment de ce que j'ai fait, sinon ca ne sert pas à grand chose :)
    • [^] # Re: sh ?

      Posté par (page perso) . Évalué à 2.

      C'est le genre de chose que je voudrais faire, mais j'aimerais trouver un truc tout près qui le fasse, si ça existe...
      C'est le genre de programme qui peut devenir vite chiant a débugger si on veut être sûr que ça marche bien. (et pour lancer 400 jobs avant les vacances, il y pas intéret à ce que ça plante deux aprés une foi que je suis dans le train sans acces au net...)

      Si vraiment je ne trouve rien, je m,y résoudrais, mais j'éspère que quelqu'un à déjà fait le boulot.
  • # jobq

    Posté par (page perso) . Évalué à 4.

    Jobq te permets de gérer une ou plusieurs liste de jobs à lancer en séquence

    http://forge.bearstech.com/trac/wiki/JobQueue
    • [^] # Re: jobq

      Posté par (page perso) . Évalué à 1.

      Presque parfais. Sont seul probleme est de ne pas gérer explicitement l'aspect multiprocesseur, mais je ferais 8 queues.
      Le seul soucis sera de répartir correctement les tâches pour que chaque queue est glabalement la même durée totale.

      Merci beaucoup pour le lien.
      • [^] # Re: jobq

        Posté par . Évalué à 3.

        ya aussi lpq ....
      • [^] # Re: jobq

        Posté par . Évalué à 1.

        Ben si tu fais 8 queues et que tu sais répartir les jobs a-la-main tu peux te passer de jobq et juste ecrire tes commandes dans 8 shell différents que tu lance en parallèle ....

        ou alors j'ai pas compris ?
        • [^] # Re: jobq

          Posté par (page perso) . Évalué à 2.

          Le truc c'est que ce n'est pas 3 commande à lancer l'une aprés l'autre mais un trés gros paquet. Et je dit bien que la on est pas encore tout à fait à ce que je cherche vu qu'il ne va pas utiliser qu'une seule file mais avec 8 commandes simultanées.

          Mais c'est quand même déjà plus simple que 8 script qui lances 50 commande à suivre chacuns, et ça permet de rajouter des tâches en cours de route.
  • # Parallel::ForkManager

    Posté par (page perso) . Évalué à 4.

    Il y a un module Perl qui permet de faire ce genre de chose facilement.

    http://search.cpan.org/~dlux/Parallel-ForkManager-0.7.5/Fork(...)

    Sur debian, cela revient à faire

    apt-get install libparallel-forkmanager-perl

    L'avantage est que ce n'est pas une usine à gaz. Un seul fichier .pm et Perl sur le poste et ça roule... Bref, c'est basique mais marche partout. A une époque, j'avais copié le .pm dans mon projet comme cela, mon programme marchait sur tous les postes GNU/Linux.

    Il y a d'autres modules du même genre mais je ne les ai jamais essayé. Chercher sur le CPAN avec "Parallel Fork"
    • [^] # Re: Parallel::ForkManager

      Posté par (page perso) . Évalué à 2.

      C'est presque parfait, je me permet une critique: il m'a fallu réécrire quelque ligne de perl puisque c'est une lib pour perl pas un programme indépendant...

      Merci beaucoup.
  • # et avec batch ?

    Posté par . Évalué à 2.

    As-tu regardé du coté de la commande batch tout simplement ? Il faut que le démon atd tourne pour que ça marche mais à priori ca devrait faire ce que tu veux :

    batch -f ma_liste_de_taches
    atrun -l 8


    atrun permet de définir la charge processeur en dessous de laquelle lancer les taches. Accessoirement, atd peux envoyer des mails quand les taches se terminent.

    Bref man 1 batch et man 1 atd...
    • [^] # Re: et avec batch ?

      Posté par (page perso) . Évalué à 2.

      Hélas ça ne marche pas dans mon cas, j'ai déjà éssayé...

      Le programme nécéssite pas mal de RAM (mais j'ai fait le truc pour pouvoir en faire tenir 8 en mémoire) et alterne des phase ou il fait beaucoup d'entrées/sorties entre la RAM et le Disque ou le Réseau, avec des phases de calcul de bourrin ou il charge a mort son proc.

      Donc quand on dans le premier type de phase, la charge du systeme est très réduite car le systeme attend les IO, alors que dans le deuxième cas la charge est maximale.

      Vu que la durée des phases est pas vraiment prévisible, il se passe des periodes ou la charge est trés basse car tous les programme attendent, mais il n'est quand même pas possible d'en lancer de nouveaux, car il vont bientot ce remttrent en phase de calcul intensif et la RAM est déjà bien pleine.

      Quand ça ce produit, c'est déjà assez chiants qu'ils bloque tous en même temps et donc ralentissent les IO des autres, je vais pas rajouter d'autres process en plus ;-)
  • # GXP

    Posté par (page perso) . Évalué à 4.

    • [^] # Re: GXP

      Posté par (page perso) . Évalué à 2.

      Yeah !!!

      Il m'a fallut un bout de temps pour trouver en quoi ça faisait ce que je vousai... Jusqu'a ce que je tombe sur la partie «embarassingly parallel»...

      Merci, beaucoup car il fait même d'autre chose dont j'ai besoin mais dont je n'avais pas parlé ici. C'est parfait.
  • # Makefile

    Posté par . Évalué à 3.

    Un Makefile ne ferait-il pas l'affaire ? Tu peux définir les dépendances entres le taches et définir le nombre de taches (option -j ) a lancer en parallèle.
    • [^] # Re: Makefile

      Posté par (page perso) . Évalué à 2.

      C'est vrai que je n'y avais pas pensé. C'est un peu gore mais ça doit trés bien marcher.
      Merci pour l'idée, je suis en train de regarder GPX car il fait pas mal d'autres choses dont j'avais besoin, mais pour plus de suretée, je vais surement plutot utiliser ta méthode ce soir avant de partir.

      Merci à tous pour toutos ces idées.
  • # make ?

    Posté par . Évalué à 1.

    sur le principe, avec un makefile du genre:


    $ cat makefile

    all: cmd1 cmd2

    cmd1:
    while [ 1 ]; do echo "hu"; sleep 5; done

    cmd2:
    while [ 1 ]; do echo "ha"; sleep 3; done
    .PHONY: cmd1 cmd2


    ensuite:
    $ make -j 2
    while [ 1 ]; do echo "hu"; sleep 5; done
    hu
    while [ 1 ]; do echo "ha"; sleep 3; done
    ha
    ha
    hu
    ha
    ha
    hu


    en oubliant pas que make exige des tabulations en début des lignes de commande (ici, devant chaque while), mais je ne sais pas comment faire apparaitre ça proprement sur linuxfr.
    pour toi, ça sera make -j 8 (man make)

    yapuka(c) écrire une moulinette pour générer le makefile (parce que se cogner les 400 commandes à la main, c'est pas glop) et roule :)

Suivre le flux des commentaires

Note : les commentaires appartiennent à ceux qui les ont postés. Nous n'en sommes pas responsables.