COMPASS  5.0.0
End-to-end AO simulation tool using GPU acceleration
Static Public Member Functions | List of all members
CarmaObjComplexInterfacer Struct Reference

#include <obj_complex.hpp>

Collaboration diagram for CarmaObjComplexInterfacer:

Static Public Member Functions

template<typename T >
static void call (py::module &mod)
 

Detailed Description

Definition at line 54 of file obj_complex.hpp.

Member Function Documentation

◆ call()

template<typename T >
static void CarmaObjComplexInterfacer::call ( py::module &  mod)
static

< sum

Definition at line 56 of file obj_complex.hpp.

56  {
57  auto name = appendName<T>("obj_");
58  using Class = CarmaObj<T>;
59  using ClassHost = CarmaHostObj<T>;
60 
61  py::class_<Class> carmaWrapObj(mod, name.data(), py::buffer_protocol());
62  carmaWrapObj.def(
63  py::init([](CarmaContext &c,
64  const py::array_t<T, py::array::f_style |
65  py::array::forcecast> &data) {
66  int ndim = data.ndim() + 1;
67  std::vector<long> data_dims(ndim);
68  data_dims[0] = data.ndim();
69  copy(data.shape(), data.shape() + data.ndim(), begin(data_dims) + 1);
70  return std::unique_ptr<Class>(
71  new Class(&c, data_dims.data(), (const T *)data.data()));
72  }),
73  "TODO", // TODO do the documentation...
74  py::arg("context").none(false), py::arg("h_data").none(false));
75 
76  carmaWrapObj.def(py::init([](CarmaContext &c, const Class &data) {
77  return std::unique_ptr<Class>(new Class(&c, &data));
78  }),
79  "TODO", // TODO do the documentation...
80  py::arg("context").none(false),
81  py::arg("d_data").none(false));
82 
83  carmaWrapObj.def_buffer([](Class &frame) -> py::buffer_info {
84  frame.sync_h_data();
85 
86  const long *dims = frame.get_dims();
87  std::vector<ssize_t> shape(dims[0]);
88  std::vector<ssize_t> strides(dims[0]);
89  ssize_t stride = sizeof(T);
90 
91  // C-style
92  // for (ssize_t dim(dims[0] - 1); dim >= 0; --dim)
93  // {
94  // shape[dim] = dims[dim + 1];
95  // strides[dim] = stride;
96  // stride *= shape[dim];
97  // }
98 
99  // F-style
100  for (ssize_t dim(0); dim < dims[0]; ++dim) {
101  shape[dim] = dims[dim + 1];
102  strides[dim] = stride;
103  stride *= shape[dim];
104  }
105 
106  return py::buffer_info(frame.get_h_data(), sizeof(T),
107  py::format_descriptor<T>::format(), dims[0], shape,
108  strides);
109  });
110 
111  carmaWrapObj.def("__repr__", &Class::to_string);
112 
113  // int get_nb_streams()
114  carmaWrapObj.def_property_readonly("nb_streams", &Class::get_nb_streams,
115  "TODO"); // TODO do the documentation...
116  // int add_stream()
117  carmaWrapObj.def("add_stream", (int (Class::*)()) & Class::add_stream,
118  "TODO"); // TODO do the documentation...
119  // int add_stream(int nb)
120  carmaWrapObj.def("add_stream", (int (Class::*)(int)) & Class::add_stream,
121  "TODO",
122  py::arg("np")); // TODO do the documentation...
123  // int del_stream()
124  carmaWrapObj.def("del_stream", (int (Class::*)()) & Class::del_stream,
125  "TODO"); // TODO do the documentation...
126  // int del_stream(int nb)
127  carmaWrapObj.def("del_stream", (int (Class::*)(int)) & Class::del_stream,
128  "TODO",
129  py::arg("np")); // TODO do the documentation...
130  // int wait_stream(int stream)
131  carmaWrapObj.def("wait_stream", &Class::wait_stream, "TODO",
132  py::arg("steam")); // TODO do the documentation...
133  carmaWrapObj.def(
134  "swap_ptr", [](Class &obj, Class &obj2) { obj.swap_ptr(obj2.get_data()); },
135  "TODO",
136  py::arg("ptr")); // TODO do the documentation...
137  // int wait_all_streams()
138  carmaWrapObj.def("wait_all_streams", &Class::wait_all_streams,
139  "TODO"); // TODO do the documentation...
140 
141  // const long *get_dims()
142  carmaWrapObj.def_property_readonly(
143  "shape",
144  [](Class &frame) -> py::array_t<long> {
145  long nb_dim = frame.get_dims(0);
146  const long *c_dim = frame.get_dims() + 1;
147  return py::array_t<long>(nb_dim, c_dim);
148  },
149  "TODO"); // TODO do the documentation...
150 
151  // int get_nb_elements()
152  carmaWrapObj.def_property_readonly("nbElem", &Class::get_nb_elements,
153  "TODO"); // TODO do the documentation...
154  // CarmaContext* get_context()
155  carmaWrapObj.def_property_readonly("context", &Class::get_context,
156  "TODO"); // TODO do the documentation...
157  // int get_device()
158  carmaWrapObj.def_property_readonly("device", &Class::get_device,
159  "TODO"); // TODO do the documentation...
160  // int get_o_data()
161  // carmaWrapObj.def_property_readonly("o_data", &Class::get_o_data_value,
162  // "TODO"); // TODO do the
163  // documentation...
164 
165  // int host2device(T_data *data);
166  carmaWrapObj.def(
167  "host2device",
168  [](Class &c,
169  py::array_t<T, py::array::f_style | py::array::forcecast> &data) {
170  c.host2device(data.data());
171  },
172  "TODO",
173  py::arg("data").none(false)); // TODO do the documentation...
174  // int device2host(T_data *data);
175  carmaWrapObj.def(
176  "device2host",
177  [](Class &c,
178  py::array_t<T, py::array::f_style | py::array::forcecast> &data) {
179  c.device2host(data.mutable_data());
180  },
181  "TODO",
182  py::arg("data").none(false)); // TODO do the documentation...
183 
184  // int copy_into(T_data *data, int nb_elem);
185  carmaWrapObj.def(
186  "copy_into",
187  [](Class &src, Class &dest, long nb_elem) {
188  if (nb_elem < 0) {
189  nb_elem = src.get_nb_elements();
190  }
191  src.copy_into(dest, nb_elem);
192  },
193  "TODO", py::arg("dest"),
194  py::arg("nb_elem") = -1); // TODO do the documentation...
195  // int copy_from(T_data *data, int nb_elem);
196  carmaWrapObj.def(
197  "copy_from",
198  [](Class &dest, Class &src, long nb_elem) {
199  if (nb_elem < 0) {
200  nb_elem = dest.get_nb_elements();
201  }
202  dest.copy_from(src, nb_elem);
203  },
204  "TODO", py::arg("data"),
205  py::arg("nb_elem") = -1); // TODO do the documentation...
206 #ifdef USE_OCTOPUS
207  carmaWrapObj.def("copy_into",
208  (int (Class::*)(ipc::Cacao<T> *)) & Class::copy_into);
209  carmaWrapObj.def("copy_from",
210  (int (Class::*)(ipc::Cacao<T> *)) & Class::copy_from);
211 #endif
212  // inline int reset()
213  carmaWrapObj.def("reset", &Class::reset,
214  "TODO"); // TODO do the documentation...
215 
217  // T_data sum();
218  // carmaWrapObj.def("sum", &Class::sum,
219  // "TODO"); // TODO do the documentation...
220  // void init_reduceCub();
221  carmaWrapObj.def("init_reduceCub", &Class::init_reduceCub,
222  "TODO"); // TODO do the documentation...
223  // void reduceCub();
224  carmaWrapObj.def("reduceCub", &Class::reduceCub,
225  "TODO"); // TODO do the documentation...
226  // void clip(T_data min, T_data max);
227  // carmaWrapObj.def(
228  // "clip", &Class::clip, "TODO", py::arg("data_min").none(false),
229  // py::arg("data_max").none(false)); // TODO do the documentation...
230 
231  // /**< transpose */
232  // int transpose(CarmaObj<T_data> *source);
233  carmaWrapObj.def(
234  "transpose", &Class::transpose, "TODO",
235  py::arg("source").none(false)); // TODO do the documentation...
236  // //CarmaObj<T_data>& operator= (const CarmaObj<T_data>& obj);
237 
238  // /**< Cublas V2 */
239  // int imax(int incx);
240  carmaWrapObj.def("aimax", &Class::aimax, "TODO",
241  py::arg("incx") = 1); // TODO do the documentation...
242  // int imin(int incx);
243  carmaWrapObj.def("aimin", &Class::aimin, "TODO",
244  py::arg("incx") = 1); // TODO do the documentation...
245  // T_data asum(int incx);
246  // carmaWrapObj.def("asum", &Class::asum, "TODO",
247  // py::arg("incx") = 1); // TODO do the documentation...
248  // T_data nrm2(int incx);
249  // carmaWrapObj.def("nrm2", &Class::nrm2, "TODO",
250  // py::arg("incx") = 1); // TODO do the documentation...
251  // T_data dot(CarmaObj<T_data> *source, int incx, int incy);
252  // carmaWrapObj.def("dot", &Class::dot, "TODO", py::arg("source").none(false),
253  // py::arg("incx") = 1,
254  // py::arg("incy") = 1); // TODO do the documentation...
255  // void scale(T_data alpha, int incx);
256  // carmaWrapObj.def("scale", &Class::scale, "TODO",
257  // py::arg("scale").none(false),
258  // py::arg("incx") = 1); // TODO do the documentation...
259  // void swap(CarmaObj<T_data> *source, int incx, int incy);
260  carmaWrapObj.def("swap", &Class::swap, "TODO",
261  py::arg("source").none(false), py::arg("incx") = 1,
262  py::arg("incy") = 1); // TODO do the documentation...
263  // void copy(CarmaObj<T_data> *source, int incx, int incy);
264  carmaWrapObj.def("copy", &Class::copy,
265  "TODO"); // TODO do the documentation...
266 
267  // /**< Curand */
268  carmaWrapObj.def("is_rng_init", &Class::is_rng_init);
269  // int init_prng();
270  carmaWrapObj.def("init_prng", (int (Class::*)()) & Class::init_prng);
271  // int init_prng(long seed);
272  carmaWrapObj.def("init_prng", (int (Class::*)(long)) & Class::init_prng);
273  // int destroy_prng();
274  carmaWrapObj.def("destroy_prng", &Class::destroy_prng);
275  // int prng(T_data *output, char gtype, float alpha, float beta);
276  // carmaWrapObj.def("prng",
277  // (int (Class::*)(T *, char, float, float)) & Class::prng);
278  // int prng(T_data *output, char gtype, float alpha);
279  // carmaWrapObj.def("prng", (int (Class::*)(T *, char, float)) & Class::prng);
280  // int prng(char gtype, float alpha, float beta);
281  carmaWrapObj.def("prng",
282  (int (Class::*)(char, float, float)) & Class::prng);
283  // int prng(char gtype, float alpha);
284  carmaWrapObj.def("prng", (int (Class::*)(char, float)) & Class::prng);
285  // int prng(char gtype);
286  carmaWrapObj.def("prng", (int (Class::*)(char)) & Class::prng);
287 
288  carmaWrapObj.def(
289  "random",
290  [](Class &data, int seed, char gtype) {
291  data.init_prng(seed);
292  data.prng(gtype);
293  },
294  py::arg("seed") = 1234, py::arg("j") = 'U');
295 
296  carmaWrapObj.def(
297  "random_host",
298  [](Class &data, int seed, char gtype) {
299  data.init_prng_host(seed);
300  data.prng_host(gtype);
301  },
302  py::arg("seed") = 1234, py::arg("j") = 'U');
303 
304  // // int prng_montagn( float init_montagn );
305  // carmaWrapObj.def("prng_montagn", &Class::prng_montagn);
306 
307  // // int init_prng_host(int seed);
308  // carmaWrapObj.def("init_prng_host",
309  // (int (Class::*)(int)) & Class::init_prng_host);
310  // // int prng_host(char gtype);
311  // carmaWrapObj.def("prng_host", (int (Class::*)(char)) & Class::prng_host);
312  // // int prng_host(char gtype, T_data stddev);
313  // carmaWrapObj.def("prng_host", (int (Class::*)(char, T)) & Class::prng_host);
314  // // int prng_host(char gtype, T_data stddev, T_data alpha);
315  // carmaWrapObj.def("prng_host",
316  // (int (Class::*)(char, T, T)) & Class::prng_host);
317  // // int destroy_prng_host();
318  // carmaWrapObj.def("destroy_prng_host", &Class::destroy_prng_host);
319 
320  carmaWrapObj.def(
321  "fft",
322  [](Class &data, Class &dest, int direction) {
323  throw std::runtime_error("not implemented");
324  // const long *dims = data.get_dims();
325  // cufftHandle *handle = data.get_plan();
326  // if(dest == nullptr) {
327  // dest = Class(data.get_context(), dims);
328  // }
329  // carma_initfft(dims, handle, carma_select_plan<T,T>());
330  // CarmaFFT(data.get_data(), dest.get_data(), direction, handle);
331  },
332  py::arg("dest") = nullptr, py::arg("direction") = 1);
333  // CU functions clip
334  // template<class T_data>
335  // void clip_array(T_data *d_data, T_data min, T_data max, int N,
336  // CarmaDevice *device);
337 
338  // CU functions sum
339  // template<class T_data>
340  // void reduce(int size, int threads, int blocks, T_data *d_idata,
341  // T_data *d_odata);
342  // template<class T_data>
343  // T_data reduce(T_data * data, int N);
344 
345  // CU functions transpose
346  // template<class T_data>
347  // int transposeCU(T_data *d_idata, T_data *d_odata, long N1, long N2);
348 
349  // CU functions generic
350  // template<class T_data>
351  // int launch_generic1d(T_data *d_idata, T_data *d_odata, int N,
352  // CarmaDevice *device);
353  // template<class T_data>
354  // int launch_generic2d(T_data *d_odata, T_data *d_idata, int N1, int N2);
355 
356  // CU functions curand
357  // int carma_prng_init(int *seed, const int nb_threads, const int nb_blocks,
358  // curandState *state);
359  // template<class T>
360  // int carma_prng_cu(T *results, const int nb_threads, const int nb_blocks,
361  // curandState *state, char gtype, int n, float alpha,
362  // float beta);
363  // template<class T>
364  // int carma_curand_montagn(curandState *state, T *d_odata, int N,
365  // CarmaDevice *device);
366 
367  // CU functions fft
368  // template<class T_in, class T_out>
369  // cufftType carma_select_plan();
370  // template<class T_in, class T_out>
371  // void carma_initfft(const long *dims_data, cufftHandle *plan, cufftType
372  // type_plan); template<class T_in, class T_out> int CarmaFFT(T_in *input,
373  // T_out *output, int dir, cufftHandle plan);
374 
375  // CU functions generic
376  // template<class T_data>
377  // int fillindex(T_data *d_odata, T_data *d_idata, int *indx, int N,
378  // CarmaDevice *device);
379  // template<class T_data>
380  // int fillvalues(T_data *d_odata, T_data val, int N,
381  // CarmaDevice *device);
382  // template<class T>
383  // int getarray2d(T *d_odata, T *d_idata, int x0, int Ncol, int NC, int N,
384  // CarmaDevice *device);
385  // template<class T>
386  // int fillarray2d(T *d_odata, T *d_idata, int x0, int Ncol, int NC, int
387  // N,
388  // CarmaDevice *device);
389  // template<class T>
390  // int fillarray2d2(T *d_odata, T *d_idata, int x0, int Ncol, int NC, int
391  // N,
392  // CarmaDevice *device);
393  // template<class T>
394  // int fill_sym_matrix(char src_uplo, T *d_data, int Ncol, int N,
395  // CarmaDevice *device);
396  // template<class T>
397  // int carma_plus(T *d_odata, T elpha, int N, CarmaDevice *device);
398  // template<class T>
399  // int carma_plusai(T *d_odata, T *i_data, int i, int sgn, int N,
400  // CarmaDevice *device);
401 
402  // CU functions fftconv
403  // int fftconv_unpad(float *d_odata, float *d_idata, int fftW, int dataH,
404  // int dataW, int N, int n, int nim);
405  // int carma_initfftconv(CarmaObjS *data_in, CarmaObjS *kernel_in, CarmaObjS
406  // *padded_data, CarmaObjC *padded_spectrum, int kernelY, int kernelX);
407 
408  // CPP functions fftconv
409  // int carma_fftconv(CarmaObjS *data_out, CarmaObjS *padded_data,
410  // CarmaObjC *padded_spectrum, int kernelY, int kernelX);
411 
412  // MAGMA functions
413 
414  // template<class T>
415  // int carma_svd(CarmaObj<T> *imat, CarmaObj<T> *eigenvals,
416  // CarmaObj<T> *mod2act, CarmaObj<T> *mes2mod);
417  // mod.def(appendName<T>("svd_").data(), &carma_svd<T>);
418 
419  // TODO after CarmaHostObj
420  // template<class T>
421  // int carma_magma_syevd(char jobz, CarmaObj<T> *mat, CarmaHostObj<T>
422  // *eigenvals);
423  // mod.def( appendName<T>("syevd_").data(), py::overload_cast<char, Class
424  // *, ClassHost *>(&carma_magma_syevd<T>)); mod.def(
425  // appendName<T>("syevd_").data(), py::overload_cast<char, long, T *, T
426  // *>(&carma_magma_syevd<T>));
427  mod.def(
428  appendName<T>("magma_syevd_").data(),
429  [](Class &d_mat_a, ClassHost &eigenvals, Class *d_U, bool computeU) {
430  if (d_U == nullptr) {
431  if (computeU) {
432  carma_magma_syevd('V', &d_mat_a, &eigenvals);
433  } else {
434  carma_magma_syevd('N', &d_mat_a, &eigenvals);
435  }
436  } else {
437  d_U->copy_from(d_mat_a, d_mat_a.get_nb_elements());
438  if (computeU) {
439  carma_magma_syevd('V', d_U, &eigenvals);
440  } else {
441  carma_magma_syevd('N', d_U, &eigenvals);
442  }
443  }
444  },
445  py::arg("d_mat_a"), py::arg("eigenvals"), py::arg("d_U") = nullptr,
446  py::arg("computeU") = true);
447 
448  mod.def(
449  appendName<T>("syevd_").data(),
450  [](Class &d_mat_a, Class &eigenvals, Class *d_U, bool computeU) {
451  if (d_U == nullptr) {
452  if (computeU) {
453  carma_syevd(CUSOLVER_EIG_MODE_VECTOR, &d_mat_a, &eigenvals);
454  } else {
455  carma_syevd(CUSOLVER_EIG_MODE_NOVECTOR, &d_mat_a, &eigenvals);
456  }
457  } else {
458  d_U->copy_from(d_mat_a, d_mat_a.get_nb_elements());
459  if (computeU) {
460  carma_syevd(CUSOLVER_EIG_MODE_VECTOR, d_U, &eigenvals);
461  } else {
462  carma_syevd(CUSOLVER_EIG_MODE_NOVECTOR, d_U, &eigenvals);
463  }
464  }
465  },
466  py::arg("d_mat_a"), py::arg("eigenvals"), py::arg("d_U") = nullptr,
467  py::arg("computeU") = true);
468  // template<class T, int method>
469  // int carma_magma_syevd(char jobz, CarmaObj<T> *mat, CarmaHostObj<T>
470  // *eigenvals); template<class T> int carma_magma_syevd_m(long ngpu, char
471  // jobz, long N, T *mat, T *eigenvals); template<class T> int
472  // carma_magma_syevd_m(long ngpu, char jobz, CarmaHostObj<T> *mat,
473  // CarmaHostObj<T> *eigenvals);
474  // template<class T>
475  // int carma_magma_syevd_m(long ngpu, char jobz, CarmaHostObj<T> *mat,
476  // CarmaHostObj<T> *eigenvals, CarmaHostObj<T> *U);
477  // template<class T>
478  // int carma_magma_getri(CarmaObj<T> *d_iA);
479  mod.def(appendName<T>("magma_getri_").data(), &carma_magma_getri<T>);
480 
481  // template<class T>
482  // int carma_magma_potri(CarmaObj<T> *d_iA);
483  mod.def(appendName<T>("magma_potri_").data(), &carma_magma_potri<T>);
484 
485  // TODO after CarmaHostObj
486  // template<class T>
487  // int carma_magma_potri_m(long num_gpus, CarmaHostObj<T> *h_A,
488  // CarmaObj<T> *d_iA);
489 
490  // MAGMA functions (direct access)
491  // template<class T>
492  // int carma_magma_syevd(char jobz, long N, T *mat, T *eigenvals);
493  // template<class T, int method>
494  // int carma_magma_syevd(char jobz, long N, T *mat, T *eigenvals);
495  // template<class T>
496  // int carma_magma_syevd_m(long ngpu, char jobz, long N, T *mat, T
497  // *eigenvals); template<class T> int carma_magma_potri_m(long num_gpus,
498  // long N, T *h_A, T *d_iA);
499 
500  }
Here is the call graph for this function:
The documentation for this struct was generated from the following file:
correlation_bokeh.data
data
Definition: correlation_bokeh.py:280
test_cublas1.c
c
Definition: test_cublas1.py:14
carma_syevd
int carma_syevd(cusolverEigMode_t jobz, CarmaObj< T > *mat, CarmaObj< T > *eigenvals)
carma_utils::to_string
std::string to_string(const T &n)
Definition: carma_utils.h:82
CarmaObj< T >
CarmaContext
this class provides the context in which CarmaObj are created
Definition: carma_context.h:104
carma_magma_syevd
int carma_magma_syevd(char jobz, CarmaObj< T > *mat, CarmaHostObj< T > *eigenvals)
CarmaHostObj
this class provides wrappers to the generic carma host object
Definition: carma_host_obj.h:68
test_rtcFHF.frame
frame
Definition: test_rtcFHF.py:36
layers_test.name
string name
Definition: layers_test.py:21