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

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

Préparation nouvelle arborescence

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