From 809e67ccef49139ba38c9f16493d59509ef29305 Mon Sep 17 00:00:00 2001 From: Jean-Philippe ARGAUD Date: Mon, 29 Apr 2019 11:44:45 +0200 Subject: [PATCH] User help to change YACS execution mode --- doc/en/advanced.rst | 53 +++++++++++++++++++++++++++++-- doc/fr/advanced.rst | 57 ++++++++++++++++++++++++++++++++-- doc/fr/tutorials_in_salome.rst | 8 ++--- 3 files changed, 110 insertions(+), 8 deletions(-) diff --git a/doc/en/advanced.rst b/doc/en/advanced.rst index 1a9adaf..cbc9cd3 100644 --- a/doc/en/advanced.rst +++ b/doc/en/advanced.rst @@ -290,10 +290,57 @@ The most comprehensive cases, proposed in :ref:`subsection_tui_advanced`, can be executed in the same way, and they give the same result as in the standard Python interface. +.. _section_advanced_execution_mode: + +Change the default execution mode of nodes in YACS +-------------------------------------------------- + +.. index:: single: YACS + +Various reasons may lead to want to change the default mode of node execution +in YACS (see [#]_ for the correct use of these possibilities). This may be for +performance reasons, or for example for reasons of resource conflicts. + +One may want to use this change in execution mode to extend the use of local +computing resources or to set remote calculations for a node that requires it. +This is particularly the case for a node that should use a simulation resource +available on a cluster, for example. + +In addition, the various calculations that are carried out (user-provided +operators, results retrieval functions, etc.) may also present conflicts if +they are performed in a single process, and in particular in the main process +of SALOME. This is the default YACS operating mode for performance and +simplicity reasons. However, it is recommended to change this functioning when +encountering execution instabilities or error messages in the graphical +interface. + +In any case, in the YACS schema being edited, it is sufficient to change the +execution mode of the node(s) that require it. They have to be executed in a +new container created for the occasion (it is not enough to use the default +container, it is explicitly necessary to create a new one) and whose properties +are adapted to the intended use. The procedure is therefore as follows: + +#. Create a new YACS container, using the context menu in the tree view of the YACS schema (usually on the left), +#. Adapt the characteristics of the container, for example by selecting a "*type*" property with the value "*multi*" for a truly parallel execution, or by choosing a remote computing resource defined by the "*Resource*" property, or by using advanced parameters, +#. Graphically select in the central view the node whose execution mode you want to change, +#. In the panel to the right of the node entries, unfold the execution choices (named "*Execution Mode*"), check the "*Container*" box instead of the "*YACS*" default, and choose the newly created container (it is usually named "*container0*"), +#. Save the modified schema + +This can be repeated for each node that requires it, by reusing the same new +container for all nodes, or by creating a new container for each node. + +.. warning:: + + this change in execution mode is extremely powerful and flexible. It is + therefore recommended that the user both use it, and at the same time be + attentive to the interaction of the different choices he makes, to avoid, for + example, an unintended performance deterioration, or computer conflicts that + are complicated to diagnose. + .. _section_advanced_observer: -Getting information on special variables during the ADAO calculation in YACS ------------------------------------------------------------------------------ +Getting information on special variables during the ADAO calculation +-------------------------------------------------------------------- .. index:: single: Observer .. index:: single: Observer Template @@ -521,3 +568,5 @@ naming of operators used to for the observation operator. The new mandatory names are "*DirectOperator*", "*TangentOperator*" and "*AdjointOperator*", as described in the last subsection of the chapter :ref:`section_reference`. The operator script files has to be modified. + +.. [#] For more information on YACS, see the *YACS module* and its integrated help available from the main menu *Help* of the SALOME platform. diff --git a/doc/fr/advanced.rst b/doc/fr/advanced.rst index d61052f..4bd3ba6 100644 --- a/doc/fr/advanced.rst +++ b/doc/fr/advanced.rst @@ -305,10 +305,61 @@ Les cas plus complets, proposés dans les :ref:`subsection_tui_advanced`, peuven être exécutés de la même manière, et ils donnent le même résultat que dans l'interface API/TUI en Python standard. +.. _section_advanced_execution_mode: + +Changer le mode par défaut d'exécution de noeuds dans YACS +---------------------------------------------------------- + +.. index:: single: YACS + +Diverses raisons peuvent conduire à vouloir modifier le mode par défaut +d'exécution de noeuds dans YACS (voir [#]_ pour le bon usage de ces +possibilités). Cela peut être pour des raisons de performances, ou par exemple +pour des raisons de conflits de ressources. + +On peut vouloir utiliser ce changement de mode d'exécution pour étendre l'usage +des ressources de calcul locales ou pour déporter les calculs d'un noeud qui le +nécessite. C'est en particulier le cas d'un noeud qui devrait utiliser une +ressource de simulation disponible sur un cluster par exemple. + +Par ailleurs, les divers calculs qui sont menés (opérateurs fournis par +l'utilisateur, fonctions de restitution des résultats, etc.) peuvent aussi +présenter des conflits s'ils sont exécutés dans un processus unique, et en +particulier dans le processus principal de SALOME. C'est le fonctionnement par +défaut de YACS pour des raisons de performances et de simplicité. Il est +néanmoins recommandé de changer ce fonctionnement lorsque l'on rencontre des +instabilités d'exécution ou des messages d'erreur au niveau de l'interface +graphique. + +Dans tous les cas, dans le schéma YACS en édition, il suffit de changer le mode +d'exécution du ou des noeuds qui le nécessitent. Il faut les exécuter dans un +nouveau conteneur créé pour l'occasion (il ne suffit pas d'utiliser le +conteneur par défaut, il faut explicitement en créer un nouveau) et dont les +caractéristiques sont adaptées à l'usage visé. La démarche est donc la suivante +: + +#. Créer un nouveau conteneur YACS, par utilisation du menu contextuel des "*Containers*" dans la vue arborescente du schéma YACS (usuellement à gauche), +#. Adapter les caractéristiques du conteneur, en sélectionnant par exemple une propriété de "*type*" valant "*multi*" pour une exécution véritablement parallèle, ou en choisissant une ressource distante de calcul définie par la propriété de "*Resource*", ou en utilisant les paramètres avancés, +#. Sélectionner graphiquement dans la vue centrale le noeud dont on veut changer le mode d'exécution, +#. Dans le panneau à droite des entrées du noeud, déplier les choix d'exécution (nommés "*Execution Mode"*), cocher la case "*Container*" à la place du défaut "*YACS*", et choisir le conteneur nouvellement créé (il porte usuellement le nom "*container0*"), +#. Enregistrer le schéma YACS modifié. + +On peut répéter cette démarche pour chaque noeud qui le nécessite, en +réutilisant le même nouveau conteneur pour tous les noeuds, ou en créant un +nouveau conteneur pour chaque noeud. + +.. warning:: + + ce changement de mode d'exécution est extrêmement puissant et souple. Il est + donc recommandé à l'utilisateur à la fois de l'utiliser, et en même temps + d'être attentif à l'interaction des différents choix qu'il effectue, pour + éviter par exemple une dégradation involontaire des performances, ou des + conflits informatiques compliqués à diagnostiquer. + .. _section_advanced_observer: -Obtenir des informations sur des variables spéciales au cours d'un calcul ADAO en YACS --------------------------------------------------------------------------------------- +Obtenir des informations sur des variables spéciales au cours d'un calcul ADAO +------------------------------------------------------------------------------ .. index:: single: Observer .. index:: single: Observer Template @@ -551,3 +602,5 @@ d'observation par script. Les nouveaux noms requis sont "*DirectOperator*", "*TangentOperator*" et "*AdjointOperator*", comme décrit dans la quatrième partie du chapitre :ref:`section_reference`. Les fichiers de script d'opérateur doivent être modifiés. + +.. [#] Pour de plus amples informations sur YACS, voir le *module YACS* et son aide intégrée disponible dans le menu principal *Aide* de l'environnement SALOME. diff --git a/doc/fr/tutorials_in_salome.rst b/doc/fr/tutorials_in_salome.rst index 1aafc79..faa4d49 100644 --- a/doc/fr/tutorials_in_salome.rst +++ b/doc/fr/tutorials_in_salome.rst @@ -189,8 +189,8 @@ schéma YACS, on obtient la représentation suivante du schéma ADAO généré : **Schéma YACS généré à partir du cas ADAO** Après ce point, toutes les modifications, exécutions et post-processing du -schéma d'assimilation de données seront effectués dans le module YACS. De -manière à vérifier les résultats d'une manière simple, on utilise le noeud +schéma d'assimilation de données seront effectués dans le module YACS. De façon +à vérifier les résultats d'une manière simple, on utilise le noeud "*UserPostAnalysis*" (ou on crée ici un nouveau noeud YACS par le sous-menu "*Noeud de script in-line*" dans la vue graphique de YACS). @@ -217,8 +217,8 @@ mise au point d'une telle procédure de post-processing peut être réalisée da YACS pour la tester, et ensuite entièrement enregistrée dans un script Python qui peut être intégré au cas ADAO en utilisant le mot-clé "*UserPostAnalysis*". -Ensuite, de manière classique dans YACS, le schéma doit être compilé, et ensuite -être exécuté. Après la fin de l'exécution, les affichages sur la sortie standard +Ensuite, de manière classique dans YACS, le schéma doit être compilé, et être +exécuté. Après la fin de l'exécution, les affichages sur la sortie standard sont disponibles dans la fenêtre "*fenêtre de sortie de YACS*" (ou "*YACS Container Log*"), obtenue par clic droit à l'aide du menu contextuel de la fenêtre "*proc*" du schéma YACS comme montré ci-dessous: -- 2.39.2