Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Merge pull request #228 from Takishipp/actor-execute
[simgrid.git] / src / smpi / bindings / smpi_pmpi_type.cpp
1 /* Copyright (c) 2007-2017. The SimGrid Team. All rights reserved.          */
2
3 /* This program is free software; you can redistribute it and/or modify it
4  * under the terms of the license (GNU LGPL) which comes with this package. */
5
6 #include "private.hpp"
7 #include "smpi_datatype_derived.hpp"
8
9 XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(smpi_pmpi);
10
11 /* PMPI User level calls */
12 extern "C" { // Obviously, the C MPI interface should use the C linkage
13
14 int PMPI_Type_free(MPI_Datatype * datatype)
15 {
16   /* Free a predefined datatype is an error according to the standard, and should be checked for */
17   if (*datatype == MPI_DATATYPE_NULL) {
18     return MPI_ERR_ARG;
19   } else {
20     simgrid::smpi::Datatype::unref(*datatype);
21     return MPI_SUCCESS;
22   }
23 }
24
25 int PMPI_Type_size(MPI_Datatype datatype, int *size)
26 {
27   if (datatype == MPI_DATATYPE_NULL) {
28     return MPI_ERR_TYPE;
29   } else if (size == nullptr) {
30     return MPI_ERR_ARG;
31   } else {
32     *size = static_cast<int>(datatype->size());
33     return MPI_SUCCESS;
34   }
35 }
36
37 int PMPI_Type_size_x(MPI_Datatype datatype, MPI_Count *size)
38 {
39   if (datatype == MPI_DATATYPE_NULL) {
40     return MPI_ERR_TYPE;
41   } else if (size == nullptr) {
42     return MPI_ERR_ARG;
43   } else {
44     *size = static_cast<MPI_Count>(datatype->size());
45     return MPI_SUCCESS;
46   }
47 }
48
49 int PMPI_Type_get_extent(MPI_Datatype datatype, MPI_Aint * lb, MPI_Aint * extent)
50 {
51   if (datatype == MPI_DATATYPE_NULL) {
52     return MPI_ERR_TYPE;
53   } else if (lb == nullptr || extent == nullptr) {
54     return MPI_ERR_ARG;
55   } else {
56     return datatype->extent(lb, extent);
57   }
58 }
59
60 int PMPI_Type_get_true_extent(MPI_Datatype datatype, MPI_Aint * lb, MPI_Aint * extent)
61 {
62   return PMPI_Type_get_extent(datatype, lb, extent);
63 }
64
65 int PMPI_Type_extent(MPI_Datatype datatype, MPI_Aint * extent)
66 {
67   if (datatype == MPI_DATATYPE_NULL) {
68     return MPI_ERR_TYPE;
69   } else if (extent == nullptr) {
70     return MPI_ERR_ARG;
71   } else {
72     *extent = datatype->get_extent();
73     return MPI_SUCCESS;
74   }
75 }
76
77 int PMPI_Type_lb(MPI_Datatype datatype, MPI_Aint * disp)
78 {
79   if (datatype == MPI_DATATYPE_NULL) {
80     return MPI_ERR_TYPE;
81   } else if (disp == nullptr) {
82     return MPI_ERR_ARG;
83   } else {
84     *disp = datatype->lb();
85     return MPI_SUCCESS;
86   }
87 }
88
89 int PMPI_Type_ub(MPI_Datatype datatype, MPI_Aint * disp)
90 {
91   if (datatype == MPI_DATATYPE_NULL) {
92     return MPI_ERR_TYPE;
93   } else if (disp == nullptr) {
94     return MPI_ERR_ARG;
95   } else {
96     *disp = datatype->ub();
97     return MPI_SUCCESS;
98   }
99 }
100
101 int PMPI_Type_dup(MPI_Datatype datatype, MPI_Datatype *newtype){
102   int retval = MPI_SUCCESS;
103   if (datatype == MPI_DATATYPE_NULL) {
104     retval=MPI_ERR_TYPE;
105   } else {
106     *newtype = new simgrid::smpi::Datatype(datatype, &retval);
107     //error when duplicating, free the new datatype
108     if(retval!=MPI_SUCCESS){
109       simgrid::smpi::Datatype::unref(*newtype);
110       *newtype = MPI_DATATYPE_NULL;
111     }
112   }
113   return retval;
114 }
115
116 int PMPI_Type_contiguous(int count, MPI_Datatype old_type, MPI_Datatype* new_type) {
117   if (old_type == MPI_DATATYPE_NULL) {
118     return MPI_ERR_TYPE;
119   } else if (count<0){
120     return MPI_ERR_COUNT;
121   } else {
122     return simgrid::smpi::Datatype::create_contiguous(count, old_type, 0, new_type);
123   }
124 }
125
126 int PMPI_Type_commit(MPI_Datatype* datatype) {
127   if (datatype == nullptr || *datatype == MPI_DATATYPE_NULL) {
128     return MPI_ERR_TYPE;
129   } else {
130     (*datatype)->commit();
131     return MPI_SUCCESS;
132   }
133 }
134
135 int PMPI_Type_vector(int count, int blocklen, int stride, MPI_Datatype old_type, MPI_Datatype* new_type) {
136   if (old_type == MPI_DATATYPE_NULL) {
137     return MPI_ERR_TYPE;
138   } else if (count<0 || blocklen<0){
139     return MPI_ERR_COUNT;
140   } else {
141     return simgrid::smpi::Datatype::create_vector(count, blocklen, stride, old_type, new_type);
142   }
143 }
144
145 int PMPI_Type_hvector(int count, int blocklen, MPI_Aint stride, MPI_Datatype old_type, MPI_Datatype* new_type) {
146   if (old_type == MPI_DATATYPE_NULL) {
147     return MPI_ERR_TYPE;
148   } else if (count<0 || blocklen<0){
149     return MPI_ERR_COUNT;
150   } else {
151     return simgrid::smpi::Datatype::create_hvector(count, blocklen, stride, old_type, new_type);
152   }
153 }
154
155 int PMPI_Type_create_hvector(int count, int blocklen, MPI_Aint stride, MPI_Datatype old_type, MPI_Datatype* new_type) {
156   return MPI_Type_hvector(count, blocklen, stride, old_type, new_type);
157 }
158
159 int PMPI_Type_indexed(int count, int* blocklens, int* indices, MPI_Datatype old_type, MPI_Datatype* new_type) {
160   if (old_type == MPI_DATATYPE_NULL) {
161     return MPI_ERR_TYPE;
162   } else if (count<0){
163     return MPI_ERR_COUNT;
164   } else {
165     return simgrid::smpi::Datatype::create_indexed(count, blocklens, indices, old_type, new_type);
166   }
167 }
168
169 int PMPI_Type_create_indexed(int count, int* blocklens, int* indices, MPI_Datatype old_type, MPI_Datatype* new_type) {
170   if (old_type == MPI_DATATYPE_NULL) {
171     return MPI_ERR_TYPE;
172   } else if (count<0){
173     return MPI_ERR_COUNT;
174   } else {
175     return simgrid::smpi::Datatype::create_indexed(count, blocklens, indices, old_type, new_type);
176   }
177 }
178
179 int PMPI_Type_create_indexed_block(int count, int blocklength, int* indices, MPI_Datatype old_type,
180                                    MPI_Datatype* new_type)
181 {
182   if (old_type == MPI_DATATYPE_NULL) {
183     return MPI_ERR_TYPE;
184   } else if (count<0){
185     return MPI_ERR_COUNT;
186   } else {
187     int* blocklens=static_cast<int*>(xbt_malloc(blocklength*count*sizeof(int)));
188     for (int i    = 0; i < count; i++)
189       blocklens[i]=blocklength;
190     int retval    = simgrid::smpi::Datatype::create_indexed(count, blocklens, indices, old_type, new_type);
191     xbt_free(blocklens);
192     return retval;
193   }
194 }
195
196 int PMPI_Type_hindexed(int count, int* blocklens, MPI_Aint* indices, MPI_Datatype old_type, MPI_Datatype* new_type)
197 {
198   if (old_type == MPI_DATATYPE_NULL) {
199     return MPI_ERR_TYPE;
200   } else if (count<0){
201     return MPI_ERR_COUNT;
202   } else {
203     return simgrid::smpi::Datatype::create_hindexed(count, blocklens, indices, old_type, new_type);
204   }
205 }
206
207 int PMPI_Type_create_hindexed(int count, int* blocklens, MPI_Aint* indices, MPI_Datatype old_type,
208                               MPI_Datatype* new_type) {
209   return PMPI_Type_hindexed(count, blocklens,indices,old_type,new_type);
210 }
211
212 int PMPI_Type_create_hindexed_block(int count, int blocklength, MPI_Aint* indices, MPI_Datatype old_type,
213                                     MPI_Datatype* new_type) {
214   if (old_type == MPI_DATATYPE_NULL) {
215     return MPI_ERR_TYPE;
216   } else if (count<0){
217     return MPI_ERR_COUNT;
218   } else {
219     int* blocklens=(int*)xbt_malloc(blocklength*count*sizeof(int));
220     for (int i     = 0; i < count; i++)
221       blocklens[i] = blocklength;
222     int retval     = simgrid::smpi::Datatype::create_hindexed(count, blocklens, indices, old_type, new_type);
223     xbt_free(blocklens);
224     return retval;
225   }
226 }
227
228 int PMPI_Type_struct(int count, int* blocklens, MPI_Aint* indices, MPI_Datatype* old_types, MPI_Datatype* new_type) {
229   if (count<0){
230     return MPI_ERR_COUNT;
231   } else {
232     return simgrid::smpi::Datatype::create_struct(count, blocklens, indices, old_types, new_type);
233   }
234 }
235
236 int PMPI_Type_create_struct(int count, int* blocklens, MPI_Aint* indices, MPI_Datatype* old_types,
237                             MPI_Datatype* new_type) {
238   return PMPI_Type_struct(count, blocklens, indices, old_types, new_type);
239 }
240
241 int PMPI_Type_create_resized(MPI_Datatype oldtype,MPI_Aint lb, MPI_Aint extent, MPI_Datatype *newtype){
242   if (oldtype == MPI_DATATYPE_NULL) {
243     return MPI_ERR_TYPE;
244   }
245   int blocks[3]         = {1, 1, 1};
246   MPI_Aint disps[3]     = {lb, 0, lb + extent};
247   MPI_Datatype types[3] = {MPI_LB, oldtype, MPI_UB};
248
249   *newtype = new simgrid::smpi::Type_Struct(oldtype->size(), lb, lb + extent, DT_FLAG_DERIVED, 3, blocks, disps, types);
250
251   (*newtype)->addflag(~DT_FLAG_COMMITED);
252   return MPI_SUCCESS;
253 }
254
255
256 int PMPI_Type_set_name(MPI_Datatype  datatype, char * name)
257 {
258   if (datatype == MPI_DATATYPE_NULL)  {
259     return MPI_ERR_TYPE;
260   } else if (name == nullptr)  {
261     return MPI_ERR_ARG;
262   } else {
263     datatype->set_name(name);
264     return MPI_SUCCESS;
265   }
266 }
267
268 int PMPI_Type_get_name(MPI_Datatype  datatype, char * name, int* len)
269 {
270   if (datatype == MPI_DATATYPE_NULL)  {
271     return MPI_ERR_TYPE;
272   } else if (name == nullptr)  {
273     return MPI_ERR_ARG;
274   } else {
275     datatype->get_name(name, len);
276     return MPI_SUCCESS;
277   }
278 }
279
280 MPI_Datatype PMPI_Type_f2c(MPI_Fint datatype){
281   return static_cast<MPI_Datatype>(simgrid::smpi::F2C::f2c(datatype));
282 }
283
284 MPI_Fint PMPI_Type_c2f(MPI_Datatype datatype){
285   return datatype->c2f();
286 }
287
288 int PMPI_Type_get_attr (MPI_Datatype type, int type_keyval, void *attribute_val, int* flag)
289 {
290   if (type==MPI_DATATYPE_NULL)
291     return MPI_ERR_TYPE;
292   else
293     return type->attr_get<simgrid::smpi::Datatype>(type_keyval, attribute_val, flag);
294 }
295
296 int PMPI_Type_set_attr (MPI_Datatype type, int type_keyval, void *attribute_val)
297 {
298   if (type==MPI_DATATYPE_NULL)
299     return MPI_ERR_TYPE;
300   else
301     return type->attr_put<simgrid::smpi::Datatype>(type_keyval, attribute_val);
302 }
303
304 int PMPI_Type_delete_attr (MPI_Datatype type, int type_keyval)
305 {
306   if (type==MPI_DATATYPE_NULL)
307     return MPI_ERR_TYPE;
308   else
309     return type->attr_delete<simgrid::smpi::Datatype>(type_keyval);
310 }
311
312 int PMPI_Type_create_keyval(MPI_Type_copy_attr_function* copy_fn, MPI_Type_delete_attr_function* delete_fn, int* keyval,
313                             void* extra_state)
314 {
315   smpi_copy_fn _copy_fn={nullptr,copy_fn,nullptr};
316   smpi_delete_fn _delete_fn={nullptr,delete_fn,nullptr};
317   return simgrid::smpi::Keyval::keyval_create<simgrid::smpi::Datatype>(_copy_fn, _delete_fn, keyval, extra_state);
318 }
319
320 int PMPI_Type_free_keyval(int* keyval) {
321   return simgrid::smpi::Keyval::keyval_free<simgrid::smpi::Datatype>(keyval);
322 }
323
324 int PMPI_Unpack(void* inbuf, int incount, int* position, void* outbuf, int outcount, MPI_Datatype type, MPI_Comm comm) {
325   if(incount<0 || outcount < 0 || inbuf==nullptr || outbuf==nullptr)
326     return MPI_ERR_ARG;
327   if (not type->is_valid())
328     return MPI_ERR_TYPE;
329   if(comm==MPI_COMM_NULL)
330     return MPI_ERR_COMM;
331   return type->unpack(inbuf, incount, position, outbuf,outcount, comm);
332 }
333
334 int PMPI_Pack(void* inbuf, int incount, MPI_Datatype type, void* outbuf, int outcount, int* position, MPI_Comm comm) {
335   if(incount<0 || outcount < 0|| inbuf==nullptr || outbuf==nullptr)
336     return MPI_ERR_ARG;
337   if (not type->is_valid())
338     return MPI_ERR_TYPE;
339   if(comm==MPI_COMM_NULL)
340     return MPI_ERR_COMM;
341   return type->pack(inbuf, incount, outbuf,outcount,position, comm);
342 }
343
344 int PMPI_Pack_size(int incount, MPI_Datatype datatype, MPI_Comm comm, int* size) {
345   if(incount<0)
346     return MPI_ERR_ARG;
347   if (not datatype->is_valid())
348     return MPI_ERR_TYPE;
349   if(comm==MPI_COMM_NULL)
350     return MPI_ERR_COMM;
351
352   *size=incount*datatype->size();
353
354   return MPI_SUCCESS;
355 }
356
357 }