PaCO++  0.05
GaBro.cc
Go to the documentation of this file.
00001 #include "GaBro.h"
00002 #include <iostream>
00003 
00004 GaBro::GaBro()
00005 {
00006   // Common
00007   _data_size = -1;
00008   _data_elt_nb = -1;
00009   _my_rank = 0;
00010   _server_nb_nodes = 1;
00011 
00012   // Client side
00013   _client_buffer = NULL;
00014   _pos = NULL;
00015   _elt_node_nb = -1;
00016   _node_pos = -1;
00017 
00018   this->setComId(-1);
00019 
00020   // Server side
00021   _server_buffer = NULL;
00022   _nb_rcp = NULL;
00023   _current_rcp = -1;
00024   _total_data_nb = -1;
00025   _node_data_nb = -1;
00026   _current_data_size = -1;
00027   _current_pos = -1;
00028 }
00029 
00030 GaBro::~GaBro() 
00031 {
00032   delete _pos;
00033   delete _nb_rcp;
00034   for(info_list_map_t::iterator it=_info_list_map.begin(); it!=_info_list_map.end(); ++it)
00035     {
00036       info_t* info = it->second;
00037       delete info;
00038       _info_list_map.erase(it);
00039     }
00040   _info_list_map.clear();
00041 }
00042 
00043 void
00044 GaBro::setSourceTopology(PaCO::PacoTopology_t topo)
00045 {
00046   _srcTopo = topo;
00047   _nb_rcp = new long[_srcTopo.total];
00048   for (unsigned int i=0; i<_srcTopo.total; i++)
00049     {
00050       _nb_rcp[i] = -1;
00051     }
00052 }
00053 
00054 PaCO::PacoTopology_t
00055 GaBro::getSourceTopology()
00056 {
00057   return _srcTopo;
00058 }
00059 
00060 void
00061 GaBro::setDestTopology(PaCO::PacoTopology_t topo)
00062 {
00063   _destTopo = topo;
00064   _server_nb_nodes = topo.total;
00065   //  _cur_info->_server_nb_nodes = _server_nb_nodes;
00066   _pos = new int[_server_nb_nodes];
00067   for (int i=0; i<_server_nb_nodes; i++)
00068     {
00069       _pos[i] = 0;
00070     }
00071 }
00072 
00073 PaCO::PacoTopology_t
00074 GaBro::getDestTopology()
00075 {
00076   return _destTopo;
00077 }
00078 
00079 void
00080 GaBro::setNodeRank(long Rank)
00081 {
00082   _my_rank = Rank;
00083   _descr.sender = Rank;
00084 }
00085 
00086 long
00087 GaBro::getNodeRank()
00088 {
00089   return _my_rank;
00090 }
00091 
00092 void
00093 GaBro::setEltSize(long size)
00094 {
00095   _data_size = size;
00096   //  _cur_info->_data_size = _data_size;
00097 }
00098 
00099 void
00100 GaBro::setTotalNbElt(long elt_nb)
00101 {
00102   _data_elt_nb = elt_nb;
00103   _descr.total_data_nb = _data_elt_nb; 
00104 }
00105 
00106 void 
00107 GaBro::setNodeNbElt(long elt_node_nb)
00108 {
00109   _elt_node_nb = elt_node_nb;
00110   //  _cur_info->_elt_node_nb = _elt_node_nb;
00111   _descr.node_data_nb = _elt_node_nb;
00112 }
00113   
00114 void 
00115 GaBro::setNodePos(long node_pos)
00116 {
00117   _node_pos = node_pos;
00118   _descr.node_position = _node_pos;
00119 }
00120 
00121 PieceToSend* 
00122 GaBro::computePiecesToSend(unsigned& size)
00123 {
00124   size = _server_nb_nodes;
00125   // Compute total data length
00126   long total_length = _data_size * _elt_node_nb;
00127   // We send at each server node the same data
00128   PieceToSend * local_vector = new PieceToSend[_server_nb_nodes];
00129   for (int i = 0; i < _server_nb_nodes; i++)
00130     {
00131       local_vector[i].sourceNode = _my_rank;
00132       local_vector[i].destNode = i;
00133       local_vector[i].size = total_length;
00134     }
00135   return local_vector;
00136 }
00137 
00138 void
00139 GaBro::setDataPtr(void* dataPtr)
00140 {
00141   _client_buffer = (char *) dataPtr;
00142 }
00143 
00144 void *
00145 GaBro::getClientData(void* pid, int server_node, long & size, long & length, bool & end)
00146 {
00147   void * result = NULL;
00148   end = true;
00149   //std:cerr << _data_size << " " << _data_elt_nb << " " << _pos[server_node] << endl;
00150   long rst_data = (_data_size * _elt_node_nb) - _pos[server_node];
00151   //std:cerr << "Size : " << size << endl;
00152   //std:cerr << "Rst_data : " << rst_data << endl;
00153   if (size == rst_data)
00154     {
00155       length = size / _data_size;
00156       _descr.current_data_size = size;
00157       result = (void *)&_client_buffer[_pos[server_node]];
00158       _pos[server_node] = _pos[server_node] + size;
00159       size = 0;
00160     }
00161   else if (size > rst_data)
00162     {
00163       length = rst_data / _data_size;
00164       _descr.current_data_size = rst_data;
00165       result = (void *)&_client_buffer[_pos[server_node]];
00166       _pos[server_node] = _pos[server_node] + rst_data;
00167       size = size - rst_data;
00168     }
00169   else if (size < rst_data)
00170     {
00171       length = size / _data_size;
00172       _descr.current_data_size = size;
00173       result = (void *)&_client_buffer[_pos[server_node]];
00174       _pos[server_node] = _pos[server_node] + size;
00175       size = 0;
00176     }
00177   return result;
00178 }
00179 
00180 void
00181 GaBro::clientFree()
00182 {
00183   for (int i=0; i<_server_nb_nodes; i++)
00184     {
00185       _pos[i] = 0;
00186     }
00187 }
00188 
00189 void *
00190 GaBro::getDescr()
00191 {
00192   return &_descr;
00193 }
00194 
00195 bool
00196 GaBro::insertData(void* rcptBuf, unsigned long element_nb)
00197 {
00198 
00199   bool ret = true;
00200   if (element_nb != 0)
00201     {
00202   if (_server_buffer == NULL)
00203     {
00204       _server_buffer = (char *)malloc(_data_size * _total_data_nb);
00205     }
00206   // Copy the buffer !!!
00207 //   cerr << "current_pos : " << _current_pos << endl;
00208 //   cerr << "data_size : " << _data_size << endl;
00209 //   cerr << "nb_rcp[_current_rcp] " << _nb_rcp[_current_rcp] << endl;  
00210 
00211   long current_sender_pos = (_current_pos * _data_size) + ((_data_size * _node_data_nb) - _nb_rcp[_current_rcp]);
00212 //   cerr << "current_sender_pos : " << current_sender_pos << endl;
00213   memcpy((void *)&(_server_buffer[current_sender_pos]), rcptBuf, _current_data_size);
00214   _nb_rcp[_current_rcp] = _nb_rcp[_current_rcp] - _current_data_size;
00215     }
00216   for (unsigned int i=0; i<_srcTopo.total; i++)
00217     {
00218       if (_nb_rcp[i] != 0)
00219    {
00220      ret = false;
00221    }
00222     }
00223   return ret;
00224 }
00225 
00226 void *
00227 GaBro::getServerData(long & length)
00228 {
00229   length = _total_data_nb;
00230   return _server_buffer;
00231 }
00232 
00233 void
00234 GaBro::setDescr(void * descr)
00235 {
00236   _descr = *((GaBroLib::GaBroDescr*) descr);
00237   if (_current_rcp == -1)
00238     {
00239       // First piece reception !
00240       _total_data_nb = _descr.total_data_nb;
00241     }
00242   _current_rcp = _descr.sender;
00243   _current_pos = _descr.node_position;
00244   _node_data_nb = _descr.node_data_nb;
00245   _current_data_size = _descr.current_data_size;
00246   //std:cerr << _current_data_size << endl;
00247   if (_nb_rcp[_current_rcp] == -1)
00248     {
00249       _nb_rcp[_current_rcp] = (_data_size * _node_data_nb);
00250     }
00251 }
00252 
00253 void
00254 GaBro::serverFree() 
00255 { 
00256   _current_rcp = -1;
00257   _current_pos = -1;
00258   _server_buffer = NULL;
00259   for (unsigned int i=0; i<_srcTopo.total; i++)
00260     {
00261       _nb_rcp[i] = -1;
00262     }
00263 }
00264 
00265 bool
00266 GaBro::setComId(long id)
00267 { 
00268   info_t * _infolists;
00269   info_list_map_t::iterator it = _info_list_map.find(id);
00270   if (it == _info_list_map.end()) 
00271     {
00272       _infolists = new info_t();
00273       _infolists->_data_size = _data_size;
00274       _infolists->_elt_node_nb = _elt_node_nb;
00275       _infolists->_server_nb_nodes = _server_nb_nodes;
00276       _infolists->_data_elt_nb = _data_elt_nb;
00277       _infolists->_node_pos = _node_pos;
00278       _info_list_map[id] = _infolists;
00279     }
00280   else 
00281     {
00282       _infolists   = it->second;
00283     }
00284   _cur_info = _infolists;
00285   _cur_id = id;
00286   _data_size = _infolists->_data_size;
00287   _elt_node_nb = _infolists->_elt_node_nb;
00288   _data_elt_nb = _infolists->_data_elt_nb;
00289   _server_nb_nodes = _infolists->_server_nb_nodes;
00290   _node_pos = _infolists->_node_pos;
00291 
00292   _descr.node_position = _node_pos;
00293   _descr.total_data_nb = _data_elt_nb; 
00294   _descr.node_data_nb = _elt_node_nb;
00295 
00296   //std:cerr << _data_size << " " << _elt_node_nb << " " << _server_nb_nodes <<endl;
00297   return true;
00298 }
00299 
00300 bool
00301 GaBro::freeComId(long id)
00302 { 
00303   if (id == -1) {
00304     //    cerr << "freeComId: not allowed to free com id -1 (ignoring)\n";
00305     return true;
00306   }
00307   if (_cur_id == id) {
00308     //    cerr << "freeComId: not allowed to free current com (ignoring)\n";
00309     return true;
00310   }
00311   //  cerr << "freeComid: communication id: "<<id<<endl;
00312   info_list_map_t::iterator it = _info_list_map.find(id);
00313   if (it != _info_list_map.end() ) 
00314     {
00315       info_t* info = it->second;
00316       delete info;
00317       _info_list_map.erase(it);
00318     }
00319   return true;
00320 }