Lancement d'un calcul

Il existe deux mécanismes pour exécuter un code avec Arcane:

1. le mécanisme avec boucle en temps qui est le mécanisme classique disponible depuis les premières versions de Arcane.
2. l'exécution directe

Pour les deux mécanismes, il faut utiliser la classe Arcane::ArcaneLauncher. Cette classe permet de spécifier les paramètres d'exécution. Toutes les méthodes de cette classe sont statiques

La première chose à faire est d'appeler la méthode Arcane::ArcaneLauncher::init() pour spécifier à Arcane les paramètres d'exécution. Cela permet d'analyser automatiquement certaines valeurs de la ligne de commande (comme le niveau de verbosité, le nom du répertoire de sortie, ...)

#include <arcane/launcher/ArcaneLauncher.h>
 
using namespace Arcane;
 
int
main(int argc,char* argv[])
{
  ArcaneLauncher::init(Arcane::CommandLineArguments(&argc,&argv));
  ...
}

Il existe deux classes permettant de spécifier les paramètres d'exécution : Arcane::ApplicationInfo et Arcane::ApplicationBuildInfo.

Note

Ces deux classes existent pour des raisons de compatiblitées avec le code existant. À terme, seule la classe Arcane::ApplicationBuildInfo restera et c'est donc cette dernière qu'il faut utiliser.

Les instances statiques de ces deux classes peuvent être récupérées via les méthodes Arcane::ArcaneLauncher::applicationInfo() et Arcane::ArcaneLauncher::applicationBuildInfo(). L'exemple suivant montre comment changer le nom et la version du code et le répertoire par défaut pour les sorties :

#include <arcane/launcher/ArcaneLauncher.h>
 
using namespace Arcane;
 
int
main(int argc,char* argv[])
{
  ArcaneLauncher::init(Arcane::CommandLineArguments(&argc,&argv));
  Arcane::ApplicationBuildInfo& app_build_info = ArcaneLauncher::applicationBuildInfo();
  app_build_info.setCodeName("ArcaneTest");
  app_build_info.setCodeVersion(VersionInfo(1,0,0));
  app_build_info.setOutputDirectory("test_output");
  ...
}

Une fois l'initialisation effectuée, il est possible de lancer l'exécution du code via l'appel à Arcane::ArcaneLauncher::run() :

#include <arcane/launcher/ArcaneLauncher.h>
 
using namespace Arcane;
 
int
main(int argc,char* argv[])
{
  ArcaneLauncher::init(Arcane::CommandLineArguments(&argc,&argv));
  Arcane::ApplicationBuildInfo& app_build_info = ArcaneLauncher::applicationBuildInfo();
  app_build_info.setCodeName("ArcaneTest");
  app_build_info.setCodeVersion(VersionInfo(1,0,0));
  app_build_info.setOutputDirectory("test_output");
  return ArcaneLauncher::run();
}

Initialisation de MPI

L'utilisation de MPI nécessite de faire un appel à la méthode MPI_Init_thread() de la bibliothèque MPI. Si Arcane est compilé avec le support de MPI, alors la détection de MPI et l'appel à MPI_Init_thread() est fait automatiquement par Arcane. Le niveau de support des threads utilisé pour l'appel à MPI_Init_thread() dépend des options telles que le nombre de tâches ou de sous-domaines locaux en mode hybride qu'on souhaite utiliser.

Il est néanmoins possible pour le code d'initialiser lui-même MPI s'il le souhaite. Pour cela, il doit appeler la méthode MPI_Init_thread() avant l'appel à Arcane::ArcaneLauncher::run().

Note

Même si l'exécutable est utilisé en séquentiel (c'est-à-dire sans passer par une commande telle que mpiexec ...), Arcane tente d'initialiser MPI. Cela est nécessaire car certaines bibliothèques (par exemple les solveurs linéaires) ont besoin que MPI soit initialisé dans tous les cas. Il est possible de modifier ce comportement en spécifiant explicitement le service de parallélisme souhaité (TODO faire doc).

Avertissement

Il faut faire attention à bien utiliser l'exécutable mpiexec qui correspond à la version de MPI avec laquelle Arcane a été compilé sinon on va lancer N fois l'exécution séquentielle.

Exécution du code

La méthode Arcane::ArcaneLauncher::run() permet de lancer l'exécution du code. Cette méthode possède trois surcharges :

1. L'appel sans argument (Arcane::ArcaneLauncher::run()) pour lancer l'exécution classique en utilisant une boucle en temps (voir Configuration du code (.CONFIG)). Ce mécanisme est à privilégier car elle permet de disposer de toutes les fonctionnalités de Arcane. La page Lancement d'un calcul montre un exemple minimal de ce type d'utilisation.
2. Arcane::ArcaneLauncher::run(std::function<int(DirectSubDomainExecutionContext&)> func) pour exécuter le code spécifié par la func après l'initialisation et la création des sous-domaines. La page arcanedoc_general_direct_execution montre un exemple d'exécution directe.
3. Arcane::ArcaneLauncher::run(std::function<int(DirectExecutionContext&)> func) pour exécuter uniquement en séquentiel le code spécifié par la func. Ce mécanisme est à utiliser si on souhaite par exemple faire des tests unitaires simples sans avoir de sous-domaine (Arcane::ISubDomain*). application sans jeu de données ni boucle en temps.

Options de la ligne de commande

Arcane interprète les options de la ligne de commande qui commencent par -A. Par exemple, pour changer le niveau de verbosité, il suffit de spécifier l'option -A,VerbosityLevel=3 dans la ligne de commande.

Les options sont interprétées lors de l'appel à Arcane::ArcaneLauncher::init() et les valeurs de ArcaneLauncher::applicationBuildInfo() sont automatiquement remplies avec ces options. Il est cependant possible de les surcharger si nécessaire.

Les options disponibles sont :

Option	Variable d'environnement	Type	Défaut	Description
T	ARCANE_NB_TASK	Int32	1	Nombre de tâches concurrentes à exécuter
S	ARCANE_NB_THREAD (Cette variable d'environnement est obsolète)	Int32		Nombre de sous-domaines en mémoire partagée
R	ARCANE_NB_REPLICATION (Cette variable d'environnement est obsolète)	Int32	1	Nombre de sous-domaines répliqués
P	ARCANE_NB_SUB_DOMAIN (Cette variable d'environnement est obsolète)	Int32		Nombre de processus à utiliser pour les sous-domaines. Cette valeur est normalement calculée automatiquement en fonction des paramètres MPI. Elle n'est utile que si on souhaite utiliser moins de processus pour le partitionnement de domaine que ceux alloués pour le calcul.
AcceleratorRuntime		string		Runtime accélérateur à utiliser. Les deux valeurs possibles sont cuda ou hip. Il faut avoir compiler Arcane avec le support des accélérateurs pour que cette option soit accessible.
MaxIteration		Int32		Nombre maximum d'itérations à effectuer pour l'exécution. Si le nombre d'itérations spécifié par cette variable est atteint, le calcul s'arrête.
OutputLevel	ARCANE_OUTPUT_LEVEL	Int32	3	Niveau de verbosité des messages sur la sortie standard.
VerbosityLevel	ARCANE_VERBOSITY_LEVEL	Int32	3	Niveau de verbosité des messages pour les sorties listings fichiers. Si l'option OutputLevel n'est pas spécifiée, cette option est aussi utilisée pour les sorties standards.
MinimalVerbosityLevel		Int32		Niveau de verbosité minimal. Si spécifié, les appels explicites dans le code pour modifier la verbosité (via Arccore::ITraceMng::setVerbosityLevel()) ne pourront pas descendre en dessous de ce niveau de verbosité minimal. Ce mécanisme est surtout utilisé en débug pour garantir l'affichage des messages.
MasterHasOutputFile	ARCANE_MASTER_HAS_OUTPUT_FILE	Bool	False	Indique si le processus maitre (en général le processus 0) écrit le listing dans un fichier en plus de la sortie standard
OutputDirectory	ARCANE_OUTPUT_DIRECTORY	String	.	Répertoire de base pour les fichiers générés (listings, logs, courbes, dépouillement, ...). Cette valeur est celle retournée par Arcane::ISubDomain::exportDirectory().
CaseDatasetFileName		String		Nom du fichier du jeu de données. Si non spécifié et requis, le dernier argument de la ligne de commande est considéré comme le nom de fichier du jeu données.
ThreadBindingStrategy	ARCANE_THREAD_BINDING_STRATEGY	String		Stratégie de punnaisage des threads. Cela fonctionne uniquement si Arcane est compilé avec la bibliothèque 'hwloc'. Par défaut aucun binding n'est effectué. Le seul mode disponible est 'Simple' qui alloue les threads suivant un mécanisme round-robin. NOTE: ce mécanisme de punnaisage est en cours de développement et il est possible qu'il ne fonctionne pas de manière optimale dans tous les cas
ParallelLoopGrainSize		Int32		Taille de grain pour les boucles parallèles multi-threadées. Si positionné, indique le nombre d'éléments de chaque bloc qui décompose une boucle multi-threadée (à partir de la version 3.8).
ParallelLoopPartitioner		String		Choix du partitionneur pour les boucles parallèles multi-threadées. Les valeurs possibles sont auto, static ou deterministic (à partir de la version 3.8).

Choix du gestionnaire d'échange de message

Le gestionnaire d'échange de message (Arcane::IParallelSuperMng) est choisi lors du lancement du calcul. Arcane fournit les gestionnaires suivants :

• MpiParallelSuperMng
• SequentialParallelSuperMng
• MpiSequentialParallelSuperMng
• SharedMemoryParallelSuperMng
• HybridParallelSuperMng

En général, Arcane choisit automatiquement le gestionnaire en fonction des paramètres utilisés pour lancer le calcul mais il est possible de spécifier explicitement le gestionnaire à utiliser en positionnant la variable d'environnement (obsolète) ARCANE_PARALLEL_SERVICE ou en spécifiant l'option MessagePassingService dans la ligne de commande avec une des valeurs ci-dessus (sans le suffixe ParallelSuperMng, donc par exemple Mpi, Sequential, MpiSequential, ...).

Le choix automatique du gestionnaire est fait comme suit :

Ligne de commande	Gestionnaire utilisé	Description
./a.out ...	MpiSequentialParallelSuperMng ou SequentialParallelSuperMng	MpiSequentialParallelSuperMng si Arcane a été compilé avec MPI, SequentialParallelSuperMng sinon. La différence entre les deux est que le premier initialise MPI afin que les communicateurs tels que MPI_COMM_WORLD puissent être utilisés
mpiexec -n $N ./a.out ...	MpiParallelSuperMng	$N processus, 1 sous-domaine par processus
./a.out -A,S=$S ...	SharedMemoryParallelSuperMng	1 processus, $S sous-domaines par processus. La communication entre les sous-domaines se fait par échange de message en mémoire partagée.
mpiexec -n $N ./a.out -A,S=$S ...	HybridParallelSuperMng	$N processus, $S sous-domaines par processus soit au total $N * $S sous-domaines.

Voici quelques exemples de lancement :

# lancement séquentiel du jeu de données 'Test.arc'
a.out Test.arc
 
# lancement avec 4 sous-domaines MPI
mpiexec -n 4 a.out Test.arc
 
# lancement avec 4 sous-domaines en mode mémoire partagée
a.out -A,S=4 Test.arc
 
# lancement avec 12 sous-domaines et 4 processus (4 sous-domaines en
# mémoire partagée par processus)
mpiexec -n 3 -c 4 a.out -A,S=4 Test.arc
 
# lancement avec le runtime accélérateur CUDA.
a.out -A,AcceleratorRuntime=cuda Test.arc

---

Exécution, runtime Lancement direct d'une exécution