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

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

Préparation nouvelle arborescence
File size: 8.2 KB
Line 
1#include "mpi_manager.hpp"
2
3#include "impi_interface.hpp"
4
5namespace xmlioserver
6{
7   namespace comm
8   {
9      /// ////////////////////// Définitions ////////////////////// ///
10
11      void CMPIManager::Initialise(int * UNUSED(argc), char *** UNUSED(argv))
12      {
13         int error = 0;
14         bool flag = false;
15
16         mpi_initialized(&flag, &error);
17         if (error != mpi_success)
18            ERROR("CMPIManager::Initialise(arc, argv)", << " MPI Error !");
19         if (!flag)
20         {
21            mpi_init(&error);
22            if (error != mpi_success)
23               ERROR("CMPIManager::Initialise(arc, argv)", << " MPI Error !");
24         }
25      }
26
27      void CMPIManager::Finalize(void)
28      {
29         int error = 0;
30         mpi_finalize(&error);
31         if (error != mpi_success)
32            ERROR("CMPIManager::Initialise(arc, argv)", << " MPI Error !");
33      }
34
35      ///--------------------------------------------------------------
36
37      int CMPIManager::GetCommRank(MPIComm comm)
38      {
39         int rank = 0, error = 0;
40         mpi_comm_rank(&comm, &rank, &error);
41         if (error != mpi_success)
42            ERROR("CMPIManager::GetCommRank(comm)", << " MPI Error !");
43         return (rank);
44      }
45
46      int CMPIManager::GetCommSize(MPIComm comm)
47      {
48         int size = 0, error = 0;
49         mpi_comm_size(&comm, &size, &error);
50         if (error != mpi_success)
51            ERROR("CMPIManager::GetCommSize(comm)", << " MPI Error !");
52         return (size);
53      }
54
55      MPIComm CMPIManager::GetCommWorld(void)
56      { 
57         return (mpi_comm_world); 
58      }
59
60      bool CMPIManager::IsMaster(MPIComm comm)
61      { 
62         return (CMPIManager::GetCommRank(comm) == 0); 
63      }
64
65      bool CMPIManager::IsRank(MPIComm comm, int rank)
66      { 
67         return (CMPIManager::GetCommRank(comm) == rank); 
68      }
69
70      MPIComm CMPIManager::CreateComm(MPIGroup group, MPIComm pcomm)
71      {
72         MPIComm  commu = 0;
73         int error = 0;
74         mpi_comm_create(&pcomm, &group, &commu, &error);
75         if (error != mpi_success)
76            ERROR("CMPIManager::CreateComm(group, pcomm)", << " MPI Error !");
77         return (commu);
78      }
79
80      //---------------------------------------------------------------
81
82      void CMPIManager::Barrier(MPIComm comm)
83      {
84         int error = 0;
85         mpi_barrier(&comm, &error);
86         if (error != mpi_success)
87            ERROR("CMPIManager::Barrier(comm)", << " MPI Error !");
88      }
89
90      //---------------------------------------------------------------
91
92      MPIGroup CMPIManager::GetGroupWorld(void)
93      {
94         MPIGroup group = 0;
95         int error = 0;
96         MPIComm  commu = CMPIManager::GetCommWorld();
97         mpi_comm_group(&commu, &group, &error);
98         if (error != mpi_success)
99            ERROR("CMPIManager::GetGroupWorld()", << " MPI Error !");
100         return (group);
101      }
102
103      MPIGroup CMPIManager::CreateSubGroup(MPIGroup pgroup, const std::vector<int> & ranks)
104      {
105         MPIGroup group = 0;
106         int size = ranks.size();
107         int error = 0;
108         mpi_group_incl(&pgroup, &size, &(ranks[0]), &group, &error);
109         if (error != mpi_success)
110            ERROR("CMPIManager::CreateSubGroup(pgroup, ranks)", << " MPI Error !");
111         return (group);
112      }
113
114      MPIGroup CMPIManager::CreateSubGroup(MPIGroup pgroup, int min_rank, int max_rank, int intval)
115      {
116         std::vector<int> ranks;
117         for (int i = min_rank; i <= max_rank; i += intval)
118            ranks.push_back(i);
119         return (CMPIManager::CreateSubGroup(pgroup, ranks));
120      }
121
122      //---------------------------------------------------------------
123
124      void CMPIManager::AllocMem(void * data, StdSize size)
125      {
126         if (MPI_Alloc_mem(sizeof(char) * size, MPI_INFO_NULL, data) != MPI_SUCCESS)
127            ERROR("CMPIManager::AllocMem(data, size)", << " MPI Error !");
128      }
129
130      void CMPIManager::FreeMem(void * data)
131      { 
132         MPI_Free_mem(data);
133      }
134
135      //--------------------------------------------------------------
136
137      void CMPIManager::Send (MPIComm comm, int dest_rank, char * data,
138                              StdSize size, MPIRequest & request)
139      {
140         MPIDataType type = mpi_char;
141         int nsize = size;
142         int tag = 0, error = 0;
143         mpi_issend(data, &nsize, &type, &dest_rank, &tag, &comm, &request, &error);
144         if (error != mpi_success)
145            ERROR("CMPIManager::Send (comm, dest_rank, data, size, request)", << " MPI Error !");
146      }
147
148      void CMPIManager::Wait (MPIRequest & request)
149      {
150         MPIStatus status = new int[mpi_status_size]();
151         int error = 0;
152         mpi_wait(&request, status, &error);
153         if (error != mpi_success)
154            ERROR("CMPIManager::Wait (request)", << " MPI Error !");
155         delete [] status;
156      }
157
158      bool CMPIManager::Test (MPIRequest & request)
159      {
160         MPIStatus status = new int[mpi_status_size]();
161         bool flag = false;
162         int error = 0;
163         mpi_test(&request, &flag, status, &error);
164         if (error != mpi_success)
165            ERROR("CMPIManager::Test (request)", << " MPI Error !");
166         delete [] status;
167         return (flag);
168      }
169
170      bool CMPIManager::HasReceivedData(MPIComm comm, int src_rank)
171      {
172         MPIStatus status = new int[mpi_status_size]();
173         bool flag = false;
174         int error = 0, tag = mpi_any_tag;
175         mpi_iprobe(&src_rank, &tag, &comm, &flag, status, &error);
176         if (error != mpi_success)
177            ERROR("CMPIManager::hasReceivedData (comm, rank)", << " MPI Error !");
178         delete [] status;
179         return (flag);
180      }
181
182      StdSize CMPIManager::GetReceivedDataSize(MPIComm comm, int src_rank)
183      {
184         MPIDataType type = mpi_char;
185         MPIStatus status = new int[mpi_status_size]();
186         bool flag = false;
187         int error = 0, size = 0, tag = mpi_any_tag;
188
189         mpi_iprobe(&src_rank, &tag, &comm, &flag, status, &error);
190         if (error != mpi_success)
191            ERROR("CMPIManager::getReceivedDataSize (comm, rank)", << " MPI Error !");
192         if (flag == false) return (0);       
193         mpi_get_count(status, &type, &size, &error);
194         if (error != mpi_success)
195            ERROR("CMPIManager::getReceivedDataSize (comm, rank)", << " MPI Error !");
196         delete [] status;
197         return (size);
198      }
199
200      void CMPIManager::Receive(MPIComm comm, int src_rank, char * data)
201      {
202         MPIRequest req = 0;
203         MPIDataType type = mpi_char;
204         int error = 0, tag = mpi_any_tag;
205         int size = CMPIManager::GetReceivedDataSize(comm, src_rank);
206
207         mpi_irecv(data, &size, &type, &src_rank, &tag, &comm, &req, &error);
208         if (error != mpi_success)
209            ERROR("CMPIManager::Receive (comm, src_rank, data)", << " MPI Error !");
210         CMPIManager::Wait (req); // Temporaire
211      }
212
213      //--------------------------------------------------------------
214
215      void CMPIManager::SendLinearBuffer
216         (MPIComm comm, int dest_rank, CLinearBuffer & buff, MPIRequest & request)
217      {
218         CMPIManager::Send(comm, dest_rank, buff, buff.getUsedSize(), request);
219         buff.clear();
220      }
221
222      void CMPIManager::ReceiveLinearBuffer(MPIComm comm, int src_rank, CLinearBuffer & buff)
223      {
224         CMPIManager::Receive(comm, src_rank, buff);
225         buff.computeBufferData();
226      }
227
228      boost::shared_ptr<CLinearBuffer> CMPIManager::ReceiveLinearBuffer(MPIComm comm, int src_rank)
229      {
230         boost::shared_ptr<CLinearBuffer> buff_ptr
231            (new CLinearBuffer(CMPIManager::GetReceivedDataSize(comm, src_rank)));
232         CMPIManager::ReceiveLinearBuffer(comm, src_rank, *buff_ptr);
233         return (buff_ptr);
234      }
235
236      void CMPIManager::ReceiveCircularBuffer(MPIComm comm, int src_rank, CCircularBuffer & buff)
237      {
238         StdSize data_size  = CMPIManager::GetReceivedDataSize(comm, src_rank);
239         StdSize data_begin = buff.prepareNextDataPosition(data_size);
240         CMPIManager::Receive(comm, src_rank, buff.getData(data_begin));
241         buff.updateNbRequests(data_begin, data_begin + data_size);
242      }
243
244      ///--------------------------------------------------------------
245
246   } // namespace comm
247} // namespace xmlioserver
Note: See TracBrowser for help on using the repository browser.