Téléchargement ygm - Téléchargement du code source ygm

ygm

Autre code source

v0.6 Release

Télécharger

Qu'est-ce que YGM?

YGM est une bibliothèque de communication asynchrone conçue pour des modèles de communication irréguliers. Il est construit sur une abstraction de communicateurs, un peu comme MPI, mais la communication est gérée de manière asynchrone et est initiée par des expéditeurs sans aucune interaction avec les récepteurs. Fonctionnalités YGM

Tampon des messages - augmente le débit de l'application.
Fire-and-Forbit RPC Semantics - Un expéditeur fournit les arguments de fonction et de fonction pour l'exécution sur un rang de destination spécifié via un appel async . Cette fonction se terminera sur le rang de destination à une heure non spécifiée à l'avenir, mais YGM ne fait pas explicitement à l'expéditeur conscient de cette réalisation.
Conteneurs de stockage - YGM fournit une collection de conteneurs de stockage distribués avec des interfaces asynchrones, utilisées pour de nombreuses opérations de mémoire distribuées courantes. Les conteneurs sont conçus pour partitionner les données, permettant aux insertions de se produire à partir de tout rang. Les données sont accessibles via des opérations collectives for_all qui exécutent une fonction fournie par l'utilisateur sur chaque objet stocké, ou, lorsque l'emplacement d'un élément particulier est connu, visit les opérations de type qui effectuent une fonction fournie par l'utilisateur uniquement sur les données souhaitées. Ces conteneurs se trouvent ici.

Commencer

Exigences

C ++ 17 - Les versions GCC 8, 9 et 10 sont testées. Votre kilométrage peut varier avec les autres compilateurs.
Bibliothèque de sérialisation C ++ C ++
MPI
Facultativement, Boost 1.77 pour activer Boost.json Support.

Utilisation de YGM avec Cmake

YGM est une bibliothèque d'en-tête uniquement qui est facile à intégrer dans un projet via CMake. Ajout des éléments suivants à CMakelists.txt installera YGM et ses dépendances dans le cadre de votre projet:

 set(DESIRED_YGM_VERSION 0.4)
find_package(ygm ${DESIRED_YGM_VERSION} CONFIG)
if (NOT ygm_FOUND)
    FetchContent_Declare(
        ygm
        GIT_REPOSITORY https://github.com/LLNL/ygm
        GIT_TAG v${DESIRED_YGM_VERSION}
    )
    FetchContent_GetProperties(ygm)
    if (ygm_POPULATED)
        message(STATUS "Found already populated ygm dependency: "
                       ${ygm_SOURCE_DIR}
        )
    else ()
        set(JUST_INSTALL_YGM ON)
        set(YGM_INSTALL ON)
        FetchContent_Populate(ygm)
        add_subdirectory(${ygm_SOURCE_DIR} ${ygm_BINARY_DIR})
        message(STATUS "Cloned ygm dependency " ${ygm_SOURCE_DIR})
    endif ()
else ()
    message(STATUS "Found installed ygm dependency " ${ygm_DIR})
endif ()

Anatomie d'un programme YGM

Ici, nous parcourons un programme YGM de base "Hello World". Le répertoire des exemples contient plusieurs autres exemples, dont beaucoup utilisant des conteneurs de stockage de YGM.

Pour commencer, les en-têtes pour un communicateur YGM sont nécessaires

# include < ygm/comm.hpp >

Au début du programme, un communicateur YGM doit être construit. Il sera donné argc et argv comme MPI_Init , et il a un troisième argument facultatif qui spécifie la taille d'agrégat (en octets) autorisée pour tous les tampons d'envoi avant que YGM ne commence les envoies de rinçage. Ici, nous ferons un tampon avec 32 Mo d'espace de tampon d'envoi agrégé.

ygm::comm world (&argc, &argv, 32 * 1024 * 1024 );

Ensuite, nous avons besoin d'un lambda pour envoyer via YGM. Nous ferons un simple type hello_world de lambda.

 auto hello_world_lambda = []( const std::string &name) {
	std::cout << " Hello " << name << std::endl;
};

Enfin, nous utilisons cette Lambda à l'intérieur de nos appels async . Dans ce cas, nous aurons le rang 0 envoyer un message au rang 1, lui disant de saluer le monde

 if (world.rank0()) {
	world. async ( 1 , hello_world_lambda, std::string ( " world " ));
}

La version complète et compilable de cet exemple se trouve ici. L'exécuter imprime un seul "Hello World".

Pièges potentiels

Lambdas autorisé

Il existe deux classes distinctes de lambdas qui peuvent être données à YGM: les lambdas distants et les lambdas locaux , chacun ayant des exigences différentes.

Lambdas éloignés

Un lambda éloigné est toute lambda qui peut potentiellement être exécutée sur un rang différent. Ces lambdas sont identifiés comme étant ceux donnés à un ygm::comm ou l'un des conteneurs de stockage via une fonction préfixée par async_ .

La caractéristique déterminante des lambdas distantes est qu'ils ne doivent capturer aucune variable; Toutes les variables doivent être fournies comme arguments. Cette limitation est due au manque de capacité pour YGM d'inspecter et d'extraire ces arguments lors de la sérialisation des messages à envoyer à d'autres rangs.

Lambdas locaux

Un lambda local est une Lambda qui est garantie de ne pas être envoyée à un rang distant. Ces lambdas sont identifiés comme étant ceux donnés à une opération for_all sur un conteneur de stockage.

La caractéristique déterminante des lambdas locales est que tous les arguments en plus de ce qui est stocké dans le conteneur doit être capturé. En interne, ces lambdas peuvent être donnés à un std::for_each qui itère sur les éléments du conteneur stocké localement sur chaque rang.