source: XMLIO_V2/dev/common/src/xmlio/server.cpp @ 274

Last change on this file since 274 was 274, checked in by hozdoba, 10 years ago

nouvelle interface fortran et corrections

File size: 10.2 KB
Line 
1#include "server.hpp"
2
3#include "tree_manager.hpp"
4#include "duration.hpp"
5#include "data_treatment.hpp"
6#include "group_template_impl.hpp"
7
8namespace xmlioserver {
9namespace comm {
10
11   /// ////////////////////// Définitions ////////////////////// ///
12   
13   CServer::CServer(MPIComm comm_client_server)
14      : blist(comm_client_server)
15   { /* Ne rien faire de plus */ } 
16       
17   CServer::~CServer(void)
18   { /* Ne rien faire de plus */ } 
19   
20   ///--------------------------------------------------------------
21
22   boost::shared_ptr<CServer> CServer::Server;
23
24   ///--------------------------------------------------------------
25   
26   const CBufferList & CServer::getBufferList(void) const 
27   {
28      return (this->blist);
29   }
30
31   ///--------------------------------------------------------------
32
33   boost::shared_ptr<CServer> CServer::CreateServer(MPIComm comm_client_server)
34   {
35      if (CServer::Server.get() != NULL)
36         CServer::Server = boost::shared_ptr<CServer>(new CServer(comm_client_server));
37      return (CServer::GetServer());
38   }
39
40   ///--------------------------------------------------------------
41
42   boost::shared_ptr<CServer> CServer::GetServer(void)
43   {
44      return (CServer::Server);
45   }
46   
47   //---------------------------------------------------------------
48   
49   void CServer::run(void)
50   {
51      while (this->blist.recvRequests())
52      {
53         long int managerId = -1, methodId  = -1, nbargs  = -1;
54         long int managerId_= -1, methodId_ = -1, nbargs_ = -1;
55         std::vector<CLinearBuffer> lbuffer;
56         this->blist.getRequests(lbuffer);
57                 
58         for (StdSize i = 0; i < lbuffer.size(); i++)
59         {           
60            lbuffer[i].getRequestInfos(0, managerId, methodId, nbargs);
61            if (((managerId_ != managerId) || (methodId_ != methodId) || (nbargs_ != nbargs)) && (i != 0 ))
62            {
63               //std::cout << managerId_ << "<->" << managerId << std::endl
64               //          << methodId_  << "<->" << methodId  << std::endl
65               //          << nbargs_    << "<->" << nbargs    << std::endl;
66               ERROR("CServer::run(void)", << "[" << i << "] Les requêtes ne sont pas synchronisées !");
67            }
68            managerId_ = managerId;
69            methodId_  = methodId;
70            nbargs_    = nbargs;
71         }
72           
73         if (managerId == 0)
74         {
75            switch(methodId)
76            {
77               case (0) :
78                  this->initialize();
79                  continue;
80               case (1) :
81                  this->finalize();
82                  return;
83               default  :
84                  ERROR("CServer::run(void)", 
85                     << "[ managerId = " << managerId << ", "
86                     << "[ methodId = "  << methodId  << ", "
87                     << "[ nbargs = "    << nbargs    << "] "
88                     << " Methode inconnue !");
89            }
90         }
91         if (managerId == 1)
92         {
93            switch(methodId)
94            {
95               case (0) :
96                  this->setContext(lbuffer);
97                  continue;
98               case (1) :
99                  this->updateCalendar(lbuffer);
100                  continue;
101               case (2) :
102                  this->setTimestep(lbuffer);
103                  continue;
104               default  :
105                  ERROR("CServer::run(void)", 
106                     << "[ managerId = " << managerId << ", "
107                     << "[ methodId = "  << methodId  << ", "
108                     << "[ nbargs = "    << nbargs    << "] "
109                     << " Methode inconnue !");
110            }
111         }
112         if (managerId == 2)
113         {
114            switch(methodId)
115            {
116               case (0) :
117                  this->writeData(lbuffer, 4);
118                  continue;
119               case (1) :
120                  this->writeData(lbuffer, 8);
121                  continue;
122               default  :
123                  ERROR("CServer::run(void)", 
124                     << "[ managerId = " << managerId << ", "
125                     << "[ methodId = "  << methodId  << ", "
126                     << "[ nbargs = "    << nbargs    << "] "
127                     << " Methode inconnue !");
128            }
129         }
130         ERROR("CServer::run(void)", 
131                << "[ managerId = " << managerId << ", "
132                << "[ methodId = "  << methodId  << ", "
133                << "[ nbargs = "    << nbargs    << "] "
134                << " Methode inconnue !");
135      }
136   }
137
138   //--------------------------------------------------------------
139   
140   void CServer::initialize(void) // manager 0, method 0
141   {
142      // Ne rien faire de plus
143   }
144   
145   //--------------------------------------------------------------
146   
147   void CServer::finalize(void) // manager 0, method 1
148   {
149       comm::CMPIManager::Barrier();
150   }   
151
152   //--------------------------------------------------------------
153
154   void CServer::setTimestep(const std::vector<CLinearBuffer> & buffer)// manager 1, method 2
155   {
156      boost::shared_ptr<CContext> context =
157         CObjectFactory::GetObject<CContext>(CObjectFactory::GetCurrentContextId());
158      boost::shared_ptr<data::CDataTreatment> dtreat = context->getDataTreatment();
159
160      StdString durationstr;
161      for (StdSize i = 0; i < buffer.size(); i++)
162      {
163         StdString durationstr_ = buffer[i].getString(3);
164         if (durationstr.compare(durationstr_) != 0 && (i != 0))
165         {
166            ERROR("CServer::setTimestep(const std::vector<CLinearBuffer> & buffer)",
167                  << "[ durationstr 1 = " << durationstr   << ", "
168                  << "[ durationstr 2 = " << durationstr_  << "] "
169                  << " Modification de timestep désynchronisé !");
170         }
171         else durationstr = durationstr_;
172
173      }
174      std::cout << "setTimestep called " << durationstr << std::endl;
175      dtreat->set_timestep(date::CDuration::FromString(durationstr));
176   }
177
178   //--------------------------------------------------------------
179             
180   void CServer::setContext(const std::vector<CLinearBuffer> & buffer) // manager 1, method 0
181   { 
182      StdString contextId;
183      for (StdSize i = 0; i < buffer.size(); i++)
184      {
185         StdString contextId_ = buffer[i].getString(3);
186         if (contextId.compare(contextId_) != 0 && (i != 0))
187         {
188            ERROR("CServer::setContext(const std::vector<CLinearBuffer> & buffer)", 
189                  << "[ contextId 1 = " << contextId   << ", "
190                  << "[ contextId 2 = " << contextId_  << "] "
191                  << " Changement de contexte désynchronisé !");
192         }
193         else contextId = contextId_;
194         
195      }
196      std::cout << "setContext called " << contextId << std::endl;
197      CTreeManager::SetCurrentContextId(contextId);
198   }
199   
200   //--------------------------------------------------------------
201   
202   void CServer::updateCalendar(const std::vector<CLinearBuffer> & buffer) // manager 1, method 1
203   {
204      boost::shared_ptr<CContext> context =
205         CObjectFactory::GetObject<CContext>(CObjectFactory::GetCurrentContextId());
206      boost::shared_ptr<data::CDataTreatment> dtreat = context->getDataTreatment();
207
208      int timestep = -1;
209      for (StdSize i = 0; i < buffer.size(); i++)
210      {
211         int timestep_ = buffer[i].getInt(3);
212         if ((timestep_ != timestep)  && (i != 0))
213         {
214            ERROR("CServer::updateCalendar(const std::vector<CLinearBuffer> & buffer)", 
215                  << "[ timestep 1 = " << timestep   << ", "
216                  << "[ timestep 2 = " << timestep_  << "] "
217                  << " Mise à jour du calendrier désynchronisée !");
218         }
219         else timestep = timestep_;
220      }
221      std::cout << "updateCalendar called " << timestep <<std::endl;
222      dtreat->update_calendar(timestep);
223   }
224   
225   //--------------------------------------------------------------
226         
227   void CServer::writeData(const std::vector<CLinearBuffer> & buffer, int prec)  // manager 2, method 0 - 1
228   {
229      boost::shared_ptr<CContext> context =
230         CObjectFactory::GetObject<CContext>(CObjectFactory::GetCurrentContextId());
231      boost::shared_ptr<data::CDataTreatment> dtreat = context->getDataTreatment();
232
233      StdString fieldId, fileId;
234      for (StdSize i = 0; i < buffer.size(); i++)
235      {
236         StdString fieldId_ = buffer[i].getString(3);
237         StdString fileId_ = buffer[i].getString(4);
238
239         if (fieldId.compare(fieldId_) != 0 && (i != 0))
240         {           
241            ERROR("CServer::writeData(const std::vector<CLinearBuffer> & buffer, int prec)", 
242                  << "[fieldId 1 = " << fieldId   << ", "
243                  << " fieldId 2 = " << fieldId_  << "] "
244                  << " Ecriture des données désynchronisée !");
245         }
246         else fieldId = fieldId_;
247
248         if (fileId.compare(fileId_) != 0 && (i != 0))
249         {
250            ERROR("CServer::writeData(const std::vector<CLinearBuffer> & buffer, int prec)",
251                  << "[fileId 1 = " << fileId   << ", "
252                  << " fileId 2 = " << fileId_  << "] "
253                  << " Ecriture des données désynchronisée !");
254         }
255         else fileId = fileId_;
256      }
257     
258      if (prec == 4)
259      {
260         std::deque<ARRAY(float, 1)> dataArray(buffer.size());
261         for (StdSize i = 0; i < buffer.size(); i++)
262            dataArray[i] = buffer[i].getFloatArray(5);
263         std::cout << "writeData called (float) " << fieldId << ", " << dataArray[0] << std::endl;
264         // Jamais atteint car les données sont transférées en tant que double
265         return;
266      }     
267      else if (prec == 8)
268      {
269         std::deque<ARRAY(double, 1)> dataArray(buffer.size());
270         for (StdSize i = 0; i < buffer.size(); i++)
271            dataArray[i] = buffer[i].getDoubleArray(5);
272         std::cout << "writeData called (double) " << fieldId << ", " << dataArray[0]  << std::endl;
273         dtreat->write_data(fieldId, fileId, dataArray);
274         return;
275      }     
276      else
277      {
278         ERROR("CServer::writeData(const std::vector<CLinearBuffer> & buffer, int prec)", 
279               << " Précision des données invalide !");
280      }
281   }
282 
283   ///--------------------------------------------------------------
284   
285   
286} // namespace comm
287} // namespace xmlioserver
Note: See TracBrowser for help on using the repository browser.