source: XMLIO_V2/dev/dev_rv/src/xmlio/manager/xios_manager.cpp @ 152

#include "xios_manager.hpp"

namespace xmlioserver
{
      /// ////////////////////// Définitions ////////////////////// ///
      void CXIOSManager::Initialise(XIOSType type, int * argc, char *** argv)
      {
         CXIOSManager::Type = type;
         if (type != CLIENT)
         {
            // Initialisation de la biliothÚque MPI si nécessaire
            comm::CMPIManager::Initialise(argc, argv);
            ExeName = StdString((*argv)[0]);
            for (int i = 1; i < *argc; i++)
               ExeOptions.push_back(StdString((*argv)[i]));
         }
      }

      void CXIOSManager::Finalize(void)
      {
         if (CXIOSManager::Type != CLIENT)
         {
            // Finalisation de la biliothÚque MPI si nécessaire
            comm::CMPIManager::Finalize();
         }
      }

      ///-------------------------------------------------------------

      StdString CXIOSManager::ExeName("unknown");
      std::vector<StdString> CXIOSManager::ExeOptions;

      CXIOSManager::XIOSType CXIOSManager::Type = CLIENT;

      StdString     CXIOSManager::ClientName;
      comm::MPIComm CXIOSManager::Comm_Client_Server;
      comm::MPIComm CXIOSManager::Comm_Server;

      xios_map<StdString, CXIOSManager::XIOSClient> CXIOSManager::Clients;

      ///--------------------------------------------------------------

      void CXIOSManager::RunClientServer(comm::MPIComm comm_client_server)
      {
         using namespace comm;
         typedef std::pair<StdString, XIOSClient> StdPairStrClient;

         MPIComm  world_comm  = CMPIManager::GetCommWorld();
         MPIGroup world_group = CMPIManager::GetGroupWorld();

         if (CMPIManager::IsMaster(comm_client_server))
         {
            std::cout << " *************************************** " << std::endl
                      << " *     XmlIOServer (Client/Server)     * " << std::endl
                      << " *************************************** " << std::endl;
            std::cout << " > Nombre de processus : "
                      << CMPIManager::GetCommSize(comm_client_server) << std::endl;
            std::cout << " > Nombre de processus utilisés : "
                      << (CXIOSManager::GetNbClient() + CXIOSManager::GetNbServer()) << std::endl;
            std::cout << " > Nombre de clients : "
                      << CXIOSManager::GetNbClient() << std::endl;
            std::cout << " > Nombre de serveurs : "
                      << CXIOSManager::GetNbServer() << std::endl;

            xios_map<StdString, XIOSClient>::iterator
               iit  = CXIOSManager::Clients.begin(),
               eend = CXIOSManager::Clients.end();

            for (;iit != eend; iit++)
            {
               const StdPairStrClient & elem = *iit;
               std::cout << " - " << elem.first
                         << " > nombre de clients : "             << elem.second.nbClient
                         << " , nombre de clients par serveur : " << elem.second.nbClientPServer
                         << " , nombre de serveurs : "            << elem.second.nbClient/elem.second.nbClientPServer
                         << std::endl;
            }

            std::cout << " *************************************** " << std::endl;
         }

         comm::CMPIManager::Barrier();
         StdSize start = 0, end   = 0;
         
         xios_map<StdString, XIOSClient>::iterator
            iit  = CXIOSManager::Clients.begin(),
            eend = CXIOSManager::Clients.end();

         for (;iit != eend; iit++)
         {
            const StdPairStrClient & elem = *iit;
            MPIComm comm_client = 0, comm_client_grp = 0; comm_client_server = 0;

            int       currentRank     = CMPIManager::GetCommRank();
            StdString clientName      = elem.first;
            StdSize   nbClient        = elem.second.nbClient;
            StdSize   nbClientPServer = elem.second.nbClientPServer;
            StdSize   nbServer        = elem.second.nbClient/elem.second.nbClientPServer;
            StdSize   totalproc       = nbClient + nbServer;

            for (StdSize i = 0; i<nbServer; i++)
            {
               end = start + nbClientPServer;
               // Pas encore implémenté (interface de gestion de groupe/communicateur buggée)
               start = start + nbClientPServer + 1;
            }
         }
      }

      void CXIOSManager::RunClient(comm::MPIComm comm_client)
      {
         (CXIOSManager::Clients.begin()->second.entry)(comm_client, comm_client, comm_client);
      }

      //---------------------------------------------------------------

      void CXIOSManager::AddClient(StdString clientName, StdSize nbClient, StdSize nbClientPServer,
                                   void (*entry_point)(comm::MPIComm, comm::MPIComm, comm::MPIComm))
      {
         StdSize nbprocess  = comm::CMPIManager::GetCommSize(comm::CMPIManager::GetCommWorld());
         StdSize nbprocess_used = CXIOSManager::GetNbClient() + CXIOSManager::GetNbServer();

         if (nbClient < nbClientPServer)
            ERROR("CXIOSManager::AddClient(clientName, nbClient, nbClientPServer, entry_point)",
                  << "nbClient < nbClientPServer");
         if ((nbClient % nbClientPServer) != 0)
            ERROR("CXIOSManager::AddClient(clientName, nbClient, nbClientPServer, entry_point)",
                  << " (nbClient % nbClientPServer) != 0 !");
         if ((nbprocess-nbprocess_used) < (nbClient + nbClient/nbClientPServer))
            ERROR("CXIOSManager::AddClient(clientName, nbClient, nbClientPServer, entry_point)",
                  << " Pas assez de processus disponibles !");
         if (CXIOSManager::Clients.find(clientName) != CXIOSManager::Clients.end())
            ERROR("CXIOSManager::AddClient(clientName, nbClient, nbClientPServer, entry_point)",
                  << " Un client portant le même nom existe déjà !");

         XIOSClient client = {nbClient, nbClientPServer, entry_point };
         CXIOSManager::Clients[clientName] = client;
      }

      //---------------------------------------------------------------

      StdSize CXIOSManager::GetNbClient(void)
      {
         switch (CXIOSManager::Type)
         {
            case (CLIENT_SERVER):
            {
               StdSize retvalue = 0;
               typedef std::pair<StdString, XIOSClient> StdPairStrClient;
               xios_map<StdString, XIOSClient>::iterator
                  iit  = CXIOSManager::Clients.begin(),
                  eend = CXIOSManager::Clients.end();

               for (;iit != eend; iit++)
               {
                  const StdPairStrClient & elem = *iit;
                  retvalue += CXIOSManager::GetNbLocClient(elem.first);
               }
               
               return (retvalue);
            }
            case (CLIENT):
               return (comm::CMPIManager::GetCommSize(CXIOSManager::Comm_Server));
            case (SERVER):
               return (comm::CMPIManager::GetCommSize(CXIOSManager::Comm_Client_Server) - 1);
            default:
               return (0);
         }
      }

      StdSize CXIOSManager::GetNbLocClient(const StdString & clientName)
      {
         switch (CXIOSManager::Type)
         {
            case (CLIENT_SERVER):
               return (CXIOSManager::Clients[clientName].nbClient);
            case (CLIENT):
            case (SERVER):
               return (CXIOSManager::GetNbClient());
            default:
               return (0);
         }
      }

      StdSize CXIOSManager::GetNbServer(void)
      {
         switch (CXIOSManager::Type)
         {
            case (CLIENT_SERVER):
            {
               StdSize retvalue = 0;
               typedef std::pair<StdString, XIOSClient> StdPairStrClient;              

               xios_map<StdString, XIOSClient>::iterator
                  iit  = CXIOSManager::Clients.begin(),
                  eend = CXIOSManager::Clients.end();

               for (;iit != eend; iit++)
               {
                  const StdPairStrClient & elem = *iit;
                  retvalue += CXIOSManager::GetNbLocServer(elem.first);
               }                  
                  
               return (retvalue);
            }
            case (CLIENT):
               return (comm::CMPIManager::GetCommSize(CXIOSManager::Comm_Server));
            case (SERVER):
               return (1);
            default:
               return (0);
         }
      }

      StdSize CXIOSManager::GetNbLocServer(const StdString & clientName)
      {
         switch (CXIOSManager::Type)
         {
            case (CLIENT_SERVER):
               return (CXIOSManager::Clients[clientName].nbClient /
                       CXIOSManager::Clients[clientName].nbClientPServer);
            case (CLIENT):
            case (SERVER):
               return (CXIOSManager::GetNbServer());
            default:
               return (0);
         }
      }

      ///--------------------------------------------------------------

} // namespace xmlioserver