doc/execpy.rst

   1
   2 .. _execpy:
   3
   4 Exécution d'un schéma de calcul avec l'interface de programmation Python
   5 ==========================================================================
   6 Il faut tout d'abord avoir un objet Python schéma de calcul que l'on appellera p.
   7 On l'obtient en utilisant la :ref:`schemapy`.
   8
   9 Si ce n'est pas déjà fait, il faut importer les modules YACS et initialiser YACS
  10 pour SALOME. Ensuite, il faut créer un objet Executor qui va exécuter le schéma de calcul.
  11
  12 Création de l'objet Executor::
  13
  14    e = pilot.ExecutorSwig()
  15
  16 Un schéma peut être exécuté selon deux modes :
  17   - le mode standard qui exécute en bloc le schéma en attendant la fin complète
  18     de l'exécution
  19   - le mode pas à pas qui permet d'exécuter partiellement le schéma et de faire
  20     des pauses et des reprises
  21
  22 Exécution du schéma en mode standard
  23 ----------------------------------------
  24 Pour ce type d'exécution, on utilise la méthode RunW de l'Executor. Cette méthode a trois arguments.
  25 Le premier est le schéma de calcul (ou même un noeud composé sous certaines conditions). Le deuxième
  26 indique le niveau de verbosité pour une exécution en mode debug (0 est le niveau sans debug, 1, 2 ou 3
  27 pour debug). Le troisième est un booléen qui vaut True si l'exécution part de zéro (tous les noeuds
  28 sont calculés) ou False si l'exécution part d'un état sauvegardé du schéma. Ces deux derniers arguments
  29 ont pour valeur par défaut 0 et True.
  30
  31 Exécution du schéma par l'objet Executor en partant de zéro, sans debug::
  32
  33    e.RunW(p)
  34    if p.getEffectiveState() != pilot.DONE:
  35      print p.getErrorReport()
  36      sys.exit(1)
  37
  38 Si l'exécution s'est bien déroulée, l'état du schéma obtenu par ``p.getEffectiveState()``
  39 vaut DONE. Si ce n'est pas le cas, le schéma est en erreur. Un compte-rendu d'erreurs (voir :ref:`errorreport`)
  40 est donné par ``p.getErrorReport()``.
  41
  42 Dans tous les cas, il est ensuite possible de récupérer les valeurs contenues dans les ports
  43 d'entrée et de sortie.
  44
  45 Sauvegarde de l'état d'un schéma
  46 ------------------------------------
  47 Suite à une exécution d'un schéma, il est possible de sauvegarder l'état du schéma dans un fichier
  48 XML pour un redémarrage ultérieur éventuel. Cette sauvegarde est réalisée en utilisant la méthode
  49 saveState du schéma de calcul. Elle prend un argument qui est le nom du fichier dans lequel
  50 sera sauvegardé l'état.
  51
  52 Voici comme se présente cet appel::
  53
  54   p.saveState("state.xml")
  55
  56 Chargement de l'état d'un schéma
  57 ------------------------------------
  58 Il est possible d'initialiser un schéma de calcul avec un état sauvegardé dans un fichier. Le schéma
  59 de calcul doit bien entendu exister. Ensuite, il faut utiliser la fonction loadState du module loader.
  60 Elle prend deux arguments : le schéma de calcul et le nom du fichier contenant l'état sauvegardé.
  61
  62 Par exemple, pour initialiser le schéma p avec l'état précédemment sauvegardé, on fera::
  63
  64   import loader
  65   loader.loadState(p,"state.xml")
  66
  67 Cette initialisation n'est possible que si les structures du schéma et de l'état sauvegardé sont identiques.
  68
  69 Après initialisation, on démarre l'exécution en passant False en troisième argument de RunW::
  70
  71   e.RunW(p,0,False)
  72
  73 Exécution du schéma en mode pas à pas
  74 ----------------------------------------
  75 Ce type d'exécution est pour des utilisateurs avancés car il nécessite l'utilisation de la programmation
  76 par thread en Python. Ne pas oublier d'importer le module threading::
  77
  78   import threading
  79
  80 Si on veut utiliser le mode pas à pas ou mettre des breakpoints, il faut exécuter le schéma dans un thread
  81 séparé et réaliser les opérations de contrôle de l'exécution dans le thread principal.
  82
  83 Exécution avec arrêt sur breakpoints
  84 +++++++++++++++++++++++++++++++++++++++
  85 Pour réaliser une exécution avec breakpoints, il faut définir la liste des breakpoints, mettre le mode
  86 d'exécution à exécution avec breakpoints puis de lancer l'exécution dans un thread séparé.
  87
  88 La liste des breakpoints est définie en passant une liste de noms de noeud à la méthode setListOfBreakPoints
  89 de l'exécuteur.
  90 Le mode est défini en utilisant la méthode setExecMode de l'exécuteur avec un paramètre de valeur 2.
  91 Les valeurs possibles sont :
  92
  93 - 0, pour un mode d'exécution standard (mode CONTINUE)
  94 - 1, pour un mode d'exécution avec pause à chaque pas d'exécution (mode STEPBYSTEP)
  95 - 2, pour un mode d'exécution avec breakpoints (mode STOPBEFORENODES)
  96
  97 Le lancement de l'exécution se fait avec la méthode RunB de l'exécuteur à la place de RunW pour une exécution
  98 standard. Les trois arguments sont les mêmes :
  99
 100 - le schéma de calcul
 101 - le niveau d'affichage (0,1,2,3)
 102 - exécution de zéro (True, False)
 103
 104 Par exemple, pour s'arrêter avant le noeud "node1", on écrira::
 105
 106   e.setListOfBreakPoints(['node1'])
 107   e.setExecMode(2)
 108   mythread=threading.Thread(target=e.RunB, args=(p,1))
 109   mythread.start()
 110
 111 Il est possible de visualiser l'état des noeuds du schéma en appelant la méthode
 112 displayDot pendant une pause::
 113
 114   e.displayDot(p)
 115
 116 Ensuite, il faut attendre que l'exécution passe en pause : une exécution passe en pause
 117 quand toutes les taches possibles avant l'exécution du noeud "node1" sont terminées.
 118 On utilise la méthode waitPause pour faire cette attente. Ensuite on arrête l'exécution
 119 par appel de la méthode stopExecution et on libère le thread. Il est conseillé de faire
 120 une petite attente avant de faire l'attente de la pause.
 121 Au total, on ajoutera la séquence suivante::
 122
 123   time.sleep(0.1)
 124   e.waitPause()
 125   e.stopExecution()
 126   mythread.join()
 127
 128 Arrêt sur breakpoint suivi d'une reprise jusqu'à la fin du schéma
 129 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 130 Pour reprendre une exécution après un arrêt sur breakpoint, il suffit de passer en mode
 131 CONTINUE et de relancer l'exécution en appelant la méthode resumeCurrentBreakPoint.
 132 L'attente de la fin de l'exécution du schéma est réalisée par appel de waitPause.
 133
 134 La séquence d'appel pour reprise sur breakpoint est la suivante::
 135
 136   e.setExecMode(0)
 137   e.resumeCurrentBreakPoint()
 138   time.sleep(0.1)
 139   e.waitPause()
 140   mythread.join()
 141
 142 Exécution en mode pas à pas
 143 +++++++++++++++++++++++++++++
 144 Lors d'une exécution en mode pas à pas, l'exécuteur de schéma de calcul se met en pause
 145 à chaque pas d'exécution. Un pas d'exécution correspond à l'exécution d'un groupe de noeuds
 146 de calcul. Ce groupe peut contenir plus d'un noeud de calcul si le schéma de calcul
 147 présente des branches d'exécution parallèles.
 148
 149 Pour passer dans ce mode on appelle la méthode setExecMode avec la valeur 1 (mode STEPBYSTEP) puis
 150 on lance l'exécuteur dans un thread comme précédemment. On attend la fin du pas d'exécution avec
 151 la méthode waitPause. On obtient la liste des noeuds du pas suivant avec la méthode getTasksToLoad.
 152 On définit la liste des noeuds à exécuter avec la méthode setStepsToExecute et on relance l'exécution
 153 avec la méthode resumeCurrentBreakPoint.
 154 Le tout doit être mis dans une boucle dont on sort à la fin de l'exécution quand il n'y a plus de noeuds
 155 à exécuter.
 156
 157 La séquence complète se présente comme suit::
 158
 159   e.setExecMode(1)
 160   mythread=threading.Thread(target=e.RunB, args=(p,0))
 161   mythread.start()
 162   time.sleep(0.1)
 163
 164   tocont = True
 165   while tocont:
 166     e.waitPause()
 167     bp=e.getTasksToLoad()
 168     if bp:
 169       e.setStepsToExecute(bp)
 170     else:
 171       tocont=False
 172     e.resumeCurrentBreakPoint()
 173
 174   time.sleep(0.1)
 175   mythread.join()
 176
 177