// 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) .
//
// 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 .
//
// For more information, please consult: .
/************************************************************************
* 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
#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_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 > & 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 > > * 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 > > tab_list_maillage_element;
// un tableau vide, qui correspond au cas du CPU 0
Tableau < list > 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 > > 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
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
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
// void serialize(Archive & ar, const unsigned int version);
};
#endif