Gérard Rio
ce2d011450
- idem pour le calcul des second membres (Algori) - idem pour le chargement pression en explicite - tests ok pour calcul MPI en RD avec pression
170 lines
7.3 KiB
C++
Executable file
170 lines
7.3 KiB
C++
Executable file
// This file is part of the Herezh++ application.
|
|
//
|
|
// The finite element software Herezh++ is dedicated to the field
|
|
// of mechanics for large transformations of solid structures.
|
|
// It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600)
|
|
// INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) <https://www.irdl.fr/>.
|
|
//
|
|
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
|
//
|
|
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
|
// AUTHOR : Gérard Rio
|
|
// E-MAIL : gerardrio56@free.fr
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License,
|
|
// or (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty
|
|
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
// See the GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
//
|
|
// For more information, please consult: <https://herezh.irdl.fr/>.
|
|
|
|
/************************************************************************
|
|
* DATE: 03/01/2022 *
|
|
* $ *
|
|
* AUTEUR: G RIO (mailto:gerardrio56@free.fr) *
|
|
* $ *
|
|
* PROJET: Herezh++ *
|
|
* $ *
|
|
************************************************************************
|
|
* BUT: une classe qui a pour objectif de gérer, calculer, *
|
|
* certaines particularités liées à la parallélisation: *
|
|
* - l'équilibrage de charge de calcul sur les processeurs *
|
|
* $ *
|
|
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' *
|
|
************************************************************************/
|
|
|
|
#ifndef DISTRIBUTION_CPU_H
|
|
#define DISTRIBUTION_CPU_H
|
|
|
|
#include <boost/serialization/split_member.hpp>
|
|
|
|
|
|
|
|
#include "LesMaillages.h"
|
|
#include "Basiques.h"
|
|
|
|
/**
|
|
*
|
|
* BUT: une classe qui a pour objectif de gérer, calculer,
|
|
* certaines particularités liées à la parallélisation:
|
|
* - l'équilibrage de charge de calcul sur les processeurs
|
|
*
|
|
*
|
|
* \author Gérard Rio
|
|
* \version 1.0
|
|
* \date 03/01/2022
|
|
* \brief classe pour gérer certaines particularités liées à la parallélisation, ex: l'équilibrage de charge de calcul sur les processeurs
|
|
*
|
|
*/
|
|
|
|
class Distribution_CPU
|
|
{
|
|
public :
|
|
// CONSTRUCTEURS :
|
|
// par défaut
|
|
Distribution_CPU();
|
|
|
|
// constructeur de copie
|
|
Distribution_CPU (const Distribution_CPU& a);
|
|
|
|
// DESTRUCTEUR :
|
|
~Distribution_CPU() {};
|
|
|
|
// METHODES PUBLIQUES :
|
|
// calcul de l'équilibrage initiale par le cpu 0
|
|
void Calcul_Equilibrage_initiale(const LesMaillages * lesMaillages);
|
|
// passage de l'équilibrage à tous les cpu autres que 0
|
|
void Passage_Equilibrage_aux_CPU();
|
|
// retour de tab_list_maillage_element(i)(j) contient la liste
|
|
// pour le maillage j des num <élément> associés au cpu i
|
|
// NB: si la taille du tableau == 0, cela signifie qu'il n'a pas encore été construit
|
|
// on peut dans ce cas déclancher un calcul d'équilibrage initial
|
|
const Tableau <Tableau < list <int > > > * Tableau_element_CPU_en_cours() const
|
|
{return &tab_list_maillage_element;};
|
|
|
|
// retour de la liste des éléments relatif au cpu en cours
|
|
// si c'est le cpu 0, retourne un tableau vide
|
|
const Tableau < list <int > > & List_element_CPU_en_cours() const
|
|
{if (ParaGlob::Monde()->rank() != 0)
|
|
return tab_list_maillage_element(ParaGlob::Monde()->rank());
|
|
else return tab_vide_list_maillage_element;
|
|
};
|
|
|
|
// retourne le tableau indicateur permettant de dire si un élément est concerné par un CPU
|
|
// tab_indic(CPU)(mail)(ele) : = 1 si l'élément ele du maillage mail est concerné
|
|
// par le CPU
|
|
const Tableau <Tableau < Tableau <bool > > > * Tab_indique_CPU_en_cours() const {return &tab_indic;};
|
|
|
|
// indicateur permettant de dire si un élément est concerné par un CPU donné
|
|
// tab_indic(CPU)(mail)(ele) : = 1 si l'élément ele du maillage mail est concerné
|
|
// par le CPU
|
|
bool Element_concerner(int CPU,int mail,int ele) const
|
|
{return tab_indic(CPU)(mail)(ele);};
|
|
|
|
// récup du nombre total d'éléments, cumul sur tous les maillages
|
|
int NB_total_element() const {return total_elem ;};
|
|
|
|
// affichage des infos relatives à la distribution
|
|
void Affiche() const ;
|
|
|
|
//============= lecture écriture dans base info ==========
|
|
// cas donne le niveau de la récupération
|
|
// = 1 : on récupère tout
|
|
// = 2 : on récupère uniquement les données variables (supposées comme telles)
|
|
void Lecture_base_info(ifstream& ent,const int cas);
|
|
// cas donne le niveau de sauvegarde
|
|
// = 1 : on sauvegarde tout
|
|
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
|
|
void Ecriture_base_info(ofstream& sort,const int cas);
|
|
|
|
|
|
private :
|
|
// VARIABLES PROTEGEES :
|
|
|
|
// tab_list_maillage_element(i)(j) contient la liste
|
|
// pour le maillage j des num <élément> associés au cpu i
|
|
Tableau <Tableau < list <int > > > tab_list_maillage_element;
|
|
// un tableau vide, qui correspond au cas du CPU 0
|
|
Tableau < list <int > > tab_vide_list_maillage_element;
|
|
|
|
// indicateur permettant de dire si un élément est concerné par un CPU donné
|
|
// tab_indic(CPU)(mail)(ele) : = 1 si l'élément ele du maillage mail est concerné
|
|
// par le CPU
|
|
Tableau <Tableau < Tableau <bool > > > tab_indic;
|
|
|
|
int total_elem ; // nombre total d'éléments cumulé sur tous les maillages
|
|
|
|
// METHODES PROTEGEES :
|
|
// -- serialisation ---
|
|
// déclaration en friend pour l'acces direct de boost
|
|
friend class boost::serialization::access;
|
|
// on spécialise la sauvegarde et la restitution
|
|
// version == 0 pour la première sauvegarde et ensuite > 0
|
|
// NB: c'est toujours la version en cours au moment de la sauvegarde
|
|
// ==> dans notre cas, on ne sent sert pas pour l'instant: supposé tjs == 0
|
|
template<class Archive>
|
|
void save(Archive & ar, const unsigned int version) const;
|
|
// en lecture, le num de version permet de ce positionner sur une version particulière
|
|
template<class Archive>
|
|
void load(Archive & ar, const unsigned int version);
|
|
// la macro suivante va définir automatiquement la méthode : "serialize"
|
|
BOOST_SERIALIZATION_SPLIT_MEMBER()
|
|
// pour mémoire on indique l'entête de la méthode "serialize"
|
|
// // la méthode serialize fonctionne dans les deux sens: lecture et écriture dans ar
|
|
// // << et >> est remplacé par &
|
|
// // le choix dépend du fait que ar est un flux entrant ou sortant
|
|
// template<class Archive>
|
|
// void serialize(Archive & ar, const unsigned int version);
|
|
|
|
};
|
|
|
|
#endif
|