Rheolef  7.2
an efficient C++ finite element environment
disarray.h
Go to the documentation of this file.
1 #ifndef _RHEO_DISARRAY_H
2 #define _RHEO_DISARRAY_H
3 //
4 // This file is part of Rheolef.
5 //
6 // Copyright (C) 2000-2009 Pierre Saramito <Pierre.Saramito@imag.fr>
7 //
8 // Rheolef is free software; you can redistribute it and/or modify
9 // it under the terms of the GNU General Public License as published by
10 // the Free Software Foundation; either version 2 of the License, or
11 // (at your option) any later version.
12 //
13 // Rheolef is distributed in the hope that it will be useful,
14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 // GNU General Public License for more details.
17 //
18 // You should have received a copy of the GNU General Public License
19 // along with Rheolef; if not, write to the Free Software
20 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 //
22 // =========================================================================
23 
24 namespace rheolef {
166 } // namespace rheolef
167 
168 
169 /*
170 Misc notes:
171  "scatter" via "get_dis_entry".
172 
173  "gather" via "dis_entry(dis_i) = value"
174  or "dis_entry(dis_i) += value". Note that += applies when T=idx_set where
175  idx_set is a wrapper class of std::set<size_t> ; the += operator represents the
176  union of a set. The operator= is used when T=double or others simple T types
177  without algebra. If there is a conflict, i.e. several processes set the dis_i
178  index, then the result of operator+= depends upon the order of the process at
179  each run and is not deterministic. Such ambiguous behavior is not detected
180  yet at run time.
181 
182 */
183 
184 #include "rheolef/communicator.h"
185 #include "rheolef/distributor.h"
186 #include "rheolef/diststream.h"
187 #include "rheolef/heap_allocator.h"
188 #include "rheolef/msg_util.h"
189 #ifdef _RHEOLEF_HAVE_MPI
190 #include "rheolef/mpi_pair_datatype.h"
191 #endif // _RHEOLEF_HAVE_MPI
192 
193 namespace rheolef {
195 template <class T>
197  std::ostream& operator() (std::ostream& os, const T& x) const { return os << x; }
198 };
199 template <class T>
201  std::ostream& operator() (std::ostream& os, const T& x) const { return os << x << ";"; }
202 };
204 template <class T>
206  std::istream& operator() (std::istream& is, T& x) const { return is >> x; }
207 };
208 } // namespace rheolef
209 // -------------------------------------------------------------
210 // the sequential representation
211 // -------------------------------------------------------------
212 namespace rheolef {
213 
214 template <class T, class M, class A> class disarray_rep {};
215 
216 template <class T, class A>
217 class disarray_rep<T,sequential,A> : public std::vector<T> { // TODO: vector<T,A> for heap_alloc
218 public:
219  typedef T value_type;
220  typedef A allocator_type;
221  typedef typename A::difference_type difference_type;
222  typedef std::vector<T> base; // TODO: vector<T,A> for heap_alloc
223  typedef typename base::size_type size_type;
224  typedef typename base::iterator iterator;
225  typedef typename base::const_iterator const_iterator;
226  typedef typename base::const_reference const_reference;
227  typedef typename base::reference reference;
231 
232  explicit disarray_rep (const A& alloc = A());
233  disarray_rep (const distributor& ownership, const T& init_val = T(), const A& alloc = A());
234  void resize (const distributor& ownership, const T& init_val = T());
235  disarray_rep (size_type loc_size = 0, const T& init_val = T(), const A& alloc = A());
236  void resize (size_type loc_size = 0, const T& init_val = T());
238 
239  A get_allocator() const { return base::get_allocator(); }
240  size_type size() const { return base::size(); }
241  iterator begin() { return base::begin(); }
242  const_iterator begin() const { return base::begin(); }
243  iterator end() { return base::end(); }
244  const_iterator end() const { return base::end(); }
245  const distributor& ownership() const { return _ownership; }
246 
247  reference operator[] (size_type i) { return base::operator[] (i); }
248  const_reference operator[] (size_type i) const { return base::operator[] (i); }
249  const_reference dis_at (size_type dis_i) const { return operator[] (dis_i); }
250 
251  size_type dis_size () const { return base::size(); }
252  size_type first_index () const { return 0; }
253  size_type last_index () const { return base::size(); }
254  reference dis_entry (size_type dis_i) { return operator[](dis_i); }
255  void get_dis_indexes (std::set<size_type>& ext_idx_set) const;
256  void reset_dis_indexes() const {}
257  template<class SetOp = typename details::default_set_op_traits<T>::type>
258  void dis_entry_assembly_begin (SetOp = SetOp()) {}
259  template<class SetOp = typename details::default_set_op_traits<T>::type>
260  void dis_entry_assembly_end (SetOp = SetOp()) {}
261  void repartition ( // old_numbering for *this
262  const disarray_rep<size_type,sequential,A>& partition, // old_ownership
263  disarray_rep<T,sequential,A>& new_disarray, // new_ownership (created)
264  disarray_rep<size_type,sequential,A>& old_numbering, // new_ownership
265  disarray_rep<size_type,sequential,A>& new_numbering) const // old_ownership
266  {
267  error_macro ("not yet");
268  }
269  template<class A2>
270  void reverse_permutation ( // old_ownership for *this=iold2dis_inew
271  disarray_rep<size_type,sequential,A2>& inew2dis_iold) const; // new_ownership
272 
273  idiststream& get_values (idiststream& s);
274  odiststream& put_values (odiststream& s) const;
275  odiststream& put_matlab (odiststream& s) const;
276  template <class GetFunction> idiststream& get_values (idiststream& ips, GetFunction get_element);
277  template <class PutFunction> odiststream& put_values (odiststream& ops, PutFunction put_element) const;
278  void dump (std::string name) const;
279 protected:
280 // data:
282 };
283 // -------------------------------------------------------------
284 // the distributed representation
285 // -------------------------------------------------------------
286 #ifdef _RHEOLEF_HAVE_MPI
287 template <class T, class A> struct disarray_dis_reference;
288 
289 template <class T, class A>
290 class disarray_rep<T,distributed,A> : public disarray_rep<T,sequential,A> {
291 public:
292 
293 // typedefs:
294 
296  using size_type = typename base::size_type;
297  using value_type = typename base::value_type;
299  using iterator = typename base::iterator;
300  using const_iterator = typename base::const_iterator;
301  using reference = typename base::reference;
302  using const_reference = typename base::const_reference;
303  using difference_type = typename base::difference_type;
305  using scatter_map_type = std::map <size_type, T>; // TODO: map<T,A> for heap_alloc
307 
308 // allocators:
309 
310  disarray_rep (const distributor& ownership, const T& init_val = T(), const A& alloc = A());
311  void resize (const distributor& ownership, const T& init_val = T());
313 
314  A get_allocator() const { return base::get_allocator(); }
315  size_type size() const { return base::size(); }
316  const_iterator begin() const { return base::begin(); }
317  const_iterator end() const { return base::end(); }
318  iterator begin() { return base::begin(); }
319  iterator end() { return base::end(); }
320 
321  const distributor& ownership() const { return base::_ownership; }
322  const mpi::communicator& comm() const { return ownership().comm(); }
323  size_type first_index () const { return ownership().first_index(); }
324  size_type last_index () const { return ownership().last_index(); }
325  size_type dis_size () const { return ownership().dis_size(); }
326 
327  dis_reference dis_entry (size_type dis_i) { return dis_reference (*this, dis_i); }
328 
329  template<class SetOp = typename details::default_set_op_traits<T>::type>
330  void dis_entry_assembly_begin (SetOp my_set_op = SetOp());
331  template<class SetOp = typename details::default_set_op_traits<T>::type>
332  void dis_entry_assembly_end (SetOp my_set_op = SetOp());
333  template<class SetOp = typename details::default_set_op_traits<T>::type>
334  void dis_entry_assembly (SetOp my_set_op = SetOp())
335  { dis_entry_assembly_begin (my_set_op); dis_entry_assembly_end (my_set_op); }
336 
337  template<class Set, class Map>
338  void append_dis_entry (const Set& ext_idx_set, Map& ext_idx_map) const;
339 
340  template<class Set, class Map>
341  void get_dis_entry (const Set& ext_idx_set, Map& ext_idx_map) const {
342  ext_idx_map.clear();
343  append_dis_entry (ext_idx_set, ext_idx_map);
344  }
345 
346  template<class Set>
347  void append_dis_indexes (const Set& ext_idx_set) const { append_dis_entry (ext_idx_set, _ext_x); }
348 
349  template<class Set>
350  void set_dis_indexes (const Set& ext_idx_set) const { get_dis_entry (ext_idx_set, _ext_x); }
351  void get_dis_indexes (std::set<size_type>& ext_idx_set) const;
352  void reset_dis_indexes() const;
353 
354  const_reference dis_at (size_type dis_i) const;
355 
356  // get all external pairs (dis_i, values):
357  const scatter_map_type& get_dis_map_entries() const { return _ext_x; }
358 
359  template<class A2>
360  void repartition ( // old_numbering for *this
361  const disarray_rep<size_type,distributed,A2>& partition, // old_ownership
362  disarray_rep<T,distributed,A>& new_disarray, // new_ownership (created)
363  disarray_rep<size_type,distributed,A2>& old_numbering, // new_ownership
364  disarray_rep<size_type,distributed,A2>& new_numbering) const; // old_ownership
365 
366  template<class A2>
367  void permutation_apply ( // old_numbering for *this
368  const disarray_rep<size_type,distributed,A2>& new_numbering, // old_ownership
369  disarray_rep<T,distributed,A>& new_disarray) const; // new_ownership (already allocated)
370 
371  template<class A2>
372  void reverse_permutation ( // old_ownership for *this=iold2dis_inew
373  disarray_rep<size_type,distributed,A2>& inew2dis_iold) const; // new_ownership
374 
375  idiststream& get_values (idiststream& s);
376  odiststream& put_values (odiststream& s) const;
377  odiststream& put_matlab (odiststream& s) const;
378  template <class GetFunction> idiststream& get_values (idiststream& ips, GetFunction get_element);
379  template <class PutFunction> odiststream& put_values (odiststream& ops, PutFunction put_element) const;
380  template <class PutFunction, class A2> odiststream& permuted_put_values (odiststream& ops, const disarray_rep<size_type,distributed,A2>& perm,
381  PutFunction put_element) const;
382  void dump (std::string name) const;
383 //protected:
384  template<class U, class SetOp>
385  void set_dis_entry (size_type dis_i, const U& val, const SetOp& set_op);
386 #ifdef TO_CLEAN
387  template<class U, class SetOp>
388  void set_plus_dis_entry (size_type dis_i, const U& val, const SetOp& set_op);
389  template<class U, class SetOp>
390  void set_minus_dis_entry (size_type dis_i, const U& val, const SetOp& set_op);
391 #endif // TO_CLEAN
392 // typedefs:
396  template<class Pair>
397  struct remove_const_in_pair {
398  typedef Pair type;
399  };
400  template<class T1, class T2>
401  struct remove_const_in_pair<std::pair<T1,T2> > {
402  typedef std::pair<typename std::decay<T1>::type,
403  typename std::decay<T2>::type> type;
404  };
405  template<class U, class IsContainer> struct stash_traits {};
406  template<class U>
407  struct stash_traits<U,std::false_type> {
408  typedef U mapped_type;
409  typedef std::map <size_type, U> map_type; // TODO: map<T,A> for heap_alloc
410  };
411  template<class U>
412  struct stash_traits<U,std::true_type> {
414  typedef std::multimap <size_type, mapped_type> map_type; // TODO: map<T,A> for heap_alloc
415  };
417  typedef typename stash_traits<T,is_container>::mapped_type stash_value;
418  typedef typename stash_traits<T,is_container>::map_type stash_map_type;
419 
422  struct message_type {
423  std::list<std::pair<size_type,mpi::request> > waits; // TODO: list<T,A> for heap_alloc
424  std::vector<std::pair<size_type,stash_value> > data; // TODO: vector<T,A> for heap_alloc
425  message_type() : waits(), data() {}
426  };
429  template<class Set, class Map>
430  void append_dis_entry (const Set& ext_idx_set, Map& ext_idx_map, std::true_type) const;
431  template<class Set, class Map>
432  void append_dis_entry (const Set& ext_idx_set, Map& ext_idx_map, std::false_type) const;
433 
434 // data:
435  stash_map_type _stash; // for assembly msgs:
436  message_type _send;
437  message_type _receive;
439  mutable scatter_map_type _ext_x; // for ext values (scatter)
440 };
441 // custom reference that interacts with stach
442 // for ext values on others partitions
443 template <class T, class A>
445 {
447 
449  : _x(x), _dis_i(dis_i) {}
450 
451 #ifndef TO_CLEAN // not usefull: default behavior
453  : _x(r._x), _dis_i(r._dis_i) {}
454 
457  _x = r._x; _dis_i = r._dis_i; return *this; }
458 #endif // TO_CLEAN
459 
461  operator= (const T& value) {
462  trace_macro("_x.set_dis_entry (dis_i="<<_dis_i<<", value="<<value<<", op=)");
463  _x.set_dis_entry (_dis_i, value, details::generic_set_op());
464  return *this;
465  }
466  template<class U>
468  operator+= (const U& value) {
469  trace_macro("_x.set_dis_entry (dis_i="<<_dis_i<<", value="<<value<<", op+=)");
470  _x.set_dis_entry (_dis_i, value, details::generic_set_plus_op());
471  return *this;
472  }
473  template<class U>
475  operator-= (const U& value) {
476  trace_macro("_x.set_dis_entry (dis_i="<<_dis_i<<", value="<<value<<", op-=)");
477  _x.set_dis_entry (_dis_i, value, details::generic_set_minus_op());
478  return *this;
479  }
480 // data:
481 protected:
484 };
485 
486 namespace details {
487 template <class T, class A>
488 struct is_class_reference<disarray_dis_reference<T,A>> : std::true_type {};
489 } // namespace details
490 
491 #endif // _RHEOLEF_HAVE_MPI
492 // -------------------------------------------------------------
493 // the basic class with a smart pointer to representation
494 // the user-level class with memory-model parameter
495 // -------------------------------------------------------------
496 template <class T, class M = rheo_default_memory_model, class A = std::allocator<T> >
497 class disarray {
498 public:
499  typedef M memory_type;
501  typedef typename rep::base::size_type size_type;
502  typedef typename rep::base::iterator iterator;
504 };
505 template <class T, class A>
506 class disarray<T,sequential,A> : public smart_pointer<disarray_rep<T,sequential,A> > {
507 public:
508 
509 // typedefs:
510 
513 
515  typedef typename rep::size_type size_type;
517  typedef typename rep::value_type value_type;
518  typedef typename rep::reference reference;
520  typedef typename rep::iterator iterator;
523 
524 // allocators:
525 
526 
527  disarray (size_type loc_size = 0, const T& init_val = T(), const A& alloc = A());
528  void resize (size_type loc_size = 0, const T& init_val = T());
529  disarray (const distributor& ownership, const T& init_val = T(), const A& alloc = A());
530  void resize (const distributor& ownership, const T& init_val = T());
531 
532 // local accessors & modifiers:
533 
534  A get_allocator() const { return base::data().get_allocator(); }
535  size_type size () const { return base::data().size(); }
536  size_type dis_size () const { return base::data().dis_size(); }
537  const distributor& ownership() const { return base::data().ownership(); }
538  const communicator& comm() const { return ownership().comm(); }
539 
540  reference operator[] (size_type i) { return base::data().operator[] (i); }
541  const_reference operator[] (size_type i) const { return base::data().operator[] (i); }
542  reference operator() (size_type i) { return base::data().operator[] (i); }
543  const_reference operator() (size_type i) const { return base::data().operator[] (i); }
544  const_reference dis_at (size_type dis_i) const { return operator[] (dis_i); }
545 
546  iterator begin() { return base::data().begin(); }
547  const_iterator begin() const { return base::data().begin(); }
548  iterator end() { return base::data().end(); }
549  const_iterator end() const { return base::data().end(); }
550 
551 // global modifiers (for compatibility with distributed interface):
552 
553  dis_reference dis_entry (size_type dis_i) { return base::data().dis_entry(dis_i); }
554  template<class SetOp = typename details::default_set_op_traits<T>::type>
555  void dis_entry_assembly (SetOp my_set_op = SetOp()) {}
556  template<class SetOp = typename details::default_set_op_traits<T>::type>
557  void dis_entry_assembly_begin (SetOp my_set_op = SetOp()) {}
558  template<class SetOp = typename details::default_set_op_traits<T>::type>
559  void dis_entry_assembly_end (SetOp my_set_op = SetOp()) {}
560 
564 
565  void get_dis_indexes (std::set<size_type>& ext_idx_set) const { base::data().get_dis_indexes (ext_idx_set); }
566  void reset_dis_indexes() const {}
567  template<class Set> void set_dis_indexes (const Set& ext_idx_set) const {}
568  template<class Set> void append_dis_indexes (const Set& ext_idx_set) const {}
569  template<class Set, class Map> void append_dis_entry (const Set& ext_idx_set, Map& ext_idx_map) const {}
570  template<class Set, class Map> void get_dis_entry (const Set& ext_idx_set, Map& ext_idx_map) const {}
571 
572 // apply a partition:
573 
574  template<class RepSize>
575  void repartition ( // old_numbering for *this
576  const RepSize& partition, // old_ownership
577  disarray<T,sequential,A>& new_disarray, // new_ownership (created)
578  RepSize& old_numbering, // new_ownership
579  RepSize& new_numbering) const // old_ownership
580  { return base::data().repartition (partition, new_disarray, old_numbering, new_numbering); }
581 
582  template<class RepSize>
583  void permutation_apply ( // old_numbering for *this
584  const RepSize& new_numbering, // old_ownership
585  disarray<T,sequential,A>& new_disarray) const // new_ownership (already allocated)
586  { return base::data().permutation_apply (new_numbering, new_disarray); }
587 
588  void reverse_permutation ( // old_ownership for *this=iold2dis_inew
589  disarray<size_type,sequential,A>& inew2dis_iold) const // new_ownership
590  { base::data().reverse_permutation (inew2dis_iold.data()); }
591 
592 // i/o:
593 
594  odiststream& put_values (odiststream& ops) const { return base::data().put_values(ops); }
595  idiststream& get_values (idiststream& ips) { return base::data().get_values(ips); }
596  template <class GetFunction>
597  idiststream& get_values (idiststream& ips, GetFunction get_element) { return base::data().get_values(ips, get_element); }
598  template <class PutFunction>
599  odiststream& put_values (odiststream& ops, PutFunction put_element) const { return base::data().put_values(ops, put_element); }
600  void dump (std::string name) const { return base::data().dump(name); }
601 };
602 template <class T, class A>
603 inline
605  size_type loc_size,
606  const T& init_val,
607  const A& alloc)
608  : base(new_macro(rep(loc_size,init_val,alloc)))
609 {
610 }
611 template <class T, class A>
612 inline
614  const distributor& ownership,
615  const T& init_val,
616  const A& alloc)
617  : base(new_macro(rep(ownership,init_val,alloc)))
618 {
619 }
620 template <class T, class A>
621 inline
622 void
624  size_type loc_size,
625  const T& init_val)
626 {
627  base::data().resize (loc_size,init_val);
628 }
629 template <class T, class A>
630 inline
631 void
633  const distributor& ownership,
634  const T& init_val)
635 {
636  base::data().resize (ownership,init_val);
637 }
638 #ifdef _RHEOLEF_HAVE_MPI
639 // [verbatim_disarray]
640 template <class T, class A>
641 class disarray<T,distributed,A> : public smart_pointer<disarray_rep<T,distributed,A> > {
642 public:
643 
644 // typedefs:
645 
648 
650  typedef typename rep::size_type size_type;
652  typedef typename rep::value_type value_type;
653  typedef typename rep::reference reference;
655  typedef typename rep::iterator iterator;
659 
660 // allocators:
661 
662  disarray (const distributor& ownership = distributor(), const T& init_val = T(), const A& alloc = A());
663  void resize (const distributor& ownership = distributor(), const T& init_val = T());
664 
665 // local accessors & modifiers:
666 
667  A get_allocator() const { return base::data().get_allocator(); }
668  size_type size () const { return base::data().size(); }
669  size_type dis_size () const { return base::data().dis_size(); }
670  const distributor& ownership() const { return base::data().ownership(); }
671  const communicator& comm() const { return base::data().comm(); }
672 
673  reference operator[] (size_type i) { return base::data().operator[] (i); }
674  const_reference operator[] (size_type i) const { return base::data().operator[] (i); }
675  reference operator() (size_type i) { return base::data().operator[] (i); }
676  const_reference operator() (size_type i) const { return base::data().operator[] (i); }
677 
678  iterator begin() { return base::data().begin(); }
679  const_iterator begin() const { return base::data().begin(); }
680  iterator end() { return base::data().end(); }
681  const_iterator end() const { return base::data().end(); }
682 
683 // global accessor:
684 
685  template<class Set, class Map>
686  void append_dis_entry (const Set& ext_idx_set, Map& ext_idx_map) const { base::data().append_dis_entry (ext_idx_set, ext_idx_map); }
687 
688  template<class Set, class Map>
689  void get_dis_entry (const Set& ext_idx_set, Map& ext_idx_map) const { base::data().get_dis_entry (ext_idx_set, ext_idx_map); }
690 
691  template<class Set>
692  void append_dis_indexes (const Set& ext_idx_set) const { base::data().append_dis_indexes (ext_idx_set); }
693  void reset_dis_indexes() const { base::data().reset_dis_indexes(); }
694  void get_dis_indexes (std::set<size_type>& ext_idx_set) const { base::data().get_dis_indexes (ext_idx_set); }
695 
696  template<class Set>
697  void set_dis_indexes (const Set& ext_idx_set) const { base::data().set_dis_indexes (ext_idx_set); }
698 
699  const T& dis_at (size_type dis_i) const { return base::data().dis_at (dis_i); }
700 
701  // get all external pairs (dis_i, values):
702  const scatter_map_type& get_dis_map_entries() const { return base::data().get_dis_map_entries(); }
703 
704 // global modifiers (for compatibility with distributed interface):
705 
706  dis_reference dis_entry (size_type dis_i) { return base::data().dis_entry(dis_i); }
707 
708  template<class SetOp = typename details::default_set_op_traits<T>::type>
709  void dis_entry_assembly_begin (SetOp my_set_op = SetOp()) { base::data().dis_entry_assembly_begin (my_set_op); }
710  template<class SetOp = typename details::default_set_op_traits<T>::type>
711  void dis_entry_assembly_end (SetOp my_set_op = SetOp()) { base::data().dis_entry_assembly_end (my_set_op); }
712  template<class SetOp = typename details::default_set_op_traits<T>::type>
713  void dis_entry_assembly (SetOp my_set_op = SetOp()) { base::data().dis_entry_assembly (my_set_op); }
714 
715  void dis_entry_assembly_begin() { base::data().template dis_entry_assembly_begin<typename details::default_set_op_traits<T>::type>(); }
716  void dis_entry_assembly_end() { base::data().template dis_entry_assembly_end<typename details::default_set_op_traits<T>::type>(); }
717  void dis_entry_assembly() { dis_entry_assembly_begin(); dis_entry_assembly_end(); }
718 
719 // apply a partition:
720 
721  template<class RepSize>
722  void repartition ( // old_numbering for *this
723  const RepSize& partition, // old_ownership
724  disarray<T,distributed>& new_disarray, // new_ownership (created)
725  RepSize& old_numbering, // new_ownership
726  RepSize& new_numbering) const // old_ownership
727  { return base::data().repartition (partition.data(), new_disarray.data(), old_numbering.data(), new_numbering.data()); }
728 
729  template<class RepSize>
730  void permutation_apply ( // old_numbering for *this
731  const RepSize& new_numbering, // old_ownership
732  disarray<T,distributed,A>& new_disarray) const // new_ownership (already allocated)
733  { base::data().permutation_apply (new_numbering.data(), new_disarray.data()); }
734 
735  void reverse_permutation ( // old_ownership for *this=iold2dis_inew
736  disarray<size_type,distributed,A>& inew2dis_iold) const // new_ownership
737  { base::data().reverse_permutation (inew2dis_iold.data()); }
738 
739 // i/o:
740 
741  odiststream& put_values (odiststream& ops) const { return base::data().put_values(ops); }
742  idiststream& get_values (idiststream& ips) { return base::data().get_values(ips); }
743  void dump (std::string name) const { return base::data().dump(name); }
744 
745  template <class GetFunction>
746  idiststream& get_values (idiststream& ips, GetFunction get_element) { return base::data().get_values(ips, get_element); }
747  template <class PutFunction>
748  odiststream& put_values (odiststream& ops, PutFunction put_element) const { return base::data().put_values(ops, put_element); }
749  template <class PutFunction, class A2> odiststream& permuted_put_values (
750  odiststream& ops, const disarray<size_type,distributed,A2>& perm, PutFunction put_element) const
751  { return base::data().permuted_put_values (ops, perm.data(), put_element); }
752 };
753 // [verbatim_disarray]
754 template <class T, class A>
755 inline
757  const distributor& ownership,
758  const T& init_val,
759  const A& alloc)
760  : base(new_macro(rep(ownership,init_val,alloc)))
761 {
762 }
763 template <class T, class A>
764 inline
765 void
767  const distributor& ownership,
768  const T & init_val)
769 {
770  base::data().resize (ownership,init_val);
771 }
772 #endif // _RHEOLEF_HAVE_MPI
773 
774 // -------------------------------------------------------------
775 // i/o with operator<< & >>
776 // -------------------------------------------------------------
777 template <class T, class A>
778 inline
781 {
782  return x.get_values(ips);
783 }
784 template <class T, class A>
785 inline
788 {
789  return x.put_values(ops);
790 }
791 #ifdef _RHEOLEF_HAVE_MPI
792 template <class T, class A>
793 inline
794 idiststream&
796 {
797  return x.get_values(ips);
798 }
799 template <class T, class A>
800 inline
803 {
804  return x.put_values(ops);
805 }
806 #endif // _RHEOLEF_HAVE_MPI
807 } // namespace rheolef
808 
809 // -------------------------------------------------------------
810 // not inlined : longer code
811 // -------------------------------------------------------------
812 #include "rheolef/disarray_seq.icc"
813 #include "rheolef/disarray_mpi.icc"
814 #endif // _RHEO_DISARRAY_H
field::size_type size_type
Definition: branch.cc:430
idiststream & get_values(idiststream &ips, GetFunction get_element)
Definition: disarray.h:746
rep::const_iterator const_iterator
Definition: disarray.h:657
const T & dis_at(size_type dis_i) const
Definition: disarray.h:699
void get_dis_entry(const Set &ext_idx_set, Map &ext_idx_map) const
Definition: disarray.h:689
void set_dis_indexes(const Set &ext_idx_set) const
Definition: disarray.h:697
const scatter_map_type & get_dis_map_entries() const
Definition: disarray.h:702
rep::scatter_map_type scatter_map_type
Definition: disarray.h:658
const_iterator begin() const
Definition: disarray.h:679
dis_reference dis_entry(size_type dis_i)
Definition: disarray.h:706
rep::difference_type difference_type
Definition: disarray.h:651
disarray_rep< T, distributed, A > rep
Definition: disarray.h:646
void repartition(const RepSize &partition, disarray< T, distributed > &new_disarray, RepSize &old_numbering, RepSize &new_numbering) const
Definition: disarray.h:722
void append_dis_indexes(const Set &ext_idx_set) const
Definition: disarray.h:692
odiststream & put_values(odiststream &ops) const
Definition: disarray.h:741
void dis_entry_assembly_begin(SetOp my_set_op=SetOp())
Definition: disarray.h:709
void permutation_apply(const RepSize &new_numbering, disarray< T, distributed, A > &new_disarray) const
Definition: disarray.h:730
const distributor & ownership() const
Definition: disarray.h:670
odiststream & put_values(odiststream &ops, PutFunction put_element) const
Definition: disarray.h:748
rep::const_reference const_reference
Definition: disarray.h:656
idiststream & get_values(idiststream &ips)
Definition: disarray.h:742
odiststream & permuted_put_values(odiststream &ops, const disarray< size_type, distributed, A2 > &perm, PutFunction put_element) const
Definition: disarray.h:749
void dis_entry_assembly_end(SetOp my_set_op=SetOp())
Definition: disarray.h:711
void get_dis_indexes(std::set< size_type > &ext_idx_set) const
Definition: disarray.h:694
void dis_entry_assembly(SetOp my_set_op=SetOp())
Definition: disarray.h:713
void reverse_permutation(disarray< size_type, distributed, A > &inew2dis_iold) const
Definition: disarray.h:735
void dump(std::string name) const
Definition: disarray.h:743
const_iterator end() const
Definition: disarray.h:681
const communicator & comm() const
Definition: disarray.h:671
void append_dis_entry(const Set &ext_idx_set, Map &ext_idx_map) const
Definition: disarray.h:686
void reverse_permutation(disarray< size_type, sequential, A > &inew2dis_iold) const
Definition: disarray.h:588
idiststream & get_values(idiststream &ips, GetFunction get_element)
Definition: disarray.h:597
rep::const_iterator const_iterator
Definition: disarray.h:522
void get_dis_entry(const Set &ext_idx_set, Map &ext_idx_map) const
Definition: disarray.h:570
const_reference dis_at(size_type dis_i) const
Definition: disarray.h:544
void set_dis_indexes(const Set &ext_idx_set) const
Definition: disarray.h:567
rep::dis_reference dis_reference
Definition: disarray.h:519
disarray_rep< T, sequential, A > rep
Definition: disarray.h:511
const_iterator begin() const
Definition: disarray.h:547
dis_reference dis_entry(size_type dis_i)
Definition: disarray.h:553
rep::difference_type difference_type
Definition: disarray.h:516
void append_dis_indexes(const Set &ext_idx_set) const
Definition: disarray.h:568
void repartition(const RepSize &partition, disarray< T, sequential, A > &new_disarray, RepSize &old_numbering, RepSize &new_numbering) const
Definition: disarray.h:575
odiststream & put_values(odiststream &ops) const
Definition: disarray.h:594
void dis_entry_assembly_begin(SetOp my_set_op=SetOp())
Definition: disarray.h:557
const distributor & ownership() const
Definition: disarray.h:537
void permutation_apply(const RepSize &new_numbering, disarray< T, sequential, A > &new_disarray) const
Definition: disarray.h:583
odiststream & put_values(odiststream &ops, PutFunction put_element) const
Definition: disarray.h:599
rep::const_reference const_reference
Definition: disarray.h:521
idiststream & get_values(idiststream &ips)
Definition: disarray.h:595
void dis_entry_assembly_end(SetOp my_set_op=SetOp())
Definition: disarray.h:559
void get_dis_indexes(std::set< size_type > &ext_idx_set) const
Definition: disarray.h:565
void dis_entry_assembly(SetOp my_set_op=SetOp())
Definition: disarray.h:555
void dump(std::string name) const
Definition: disarray.h:600
const_iterator end() const
Definition: disarray.h:549
const communicator & comm() const
Definition: disarray.h:538
void append_dis_entry(const Set &ext_idx_set, Map &ext_idx_map) const
Definition: disarray.h:569
typename base::value_type value_type
Definition: disarray.h:297
void get_dis_entry(const Set &ext_idx_set, Map &ext_idx_map) const
Definition: disarray.h:341
void set_dis_indexes(const Set &ext_idx_set) const
Definition: disarray.h:350
typename base::const_reference const_reference
Definition: disarray.h:302
const scatter_map_type & get_dis_map_entries() const
Definition: disarray.h:357
typename base::reference reference
Definition: disarray.h:301
dis_reference dis_entry(size_type dis_i)
Definition: disarray.h:327
stash_traits< T, is_container >::mapped_type stash_value
Definition: disarray.h:417
std::map< size_type, T > scatter_map_type
Definition: disarray.h:305
details::is_container_of_mpi_datatype< T >::type is_container
Definition: disarray.h:416
void append_dis_indexes(const Set &ext_idx_set) const
Definition: disarray.h:347
const mpi::communicator & comm() const
Definition: disarray.h:322
const distributor & ownership() const
Definition: disarray.h:321
typename base::difference_type difference_type
Definition: disarray.h:303
typename base::size_type size_type
Definition: disarray.h:296
typename base::const_iterator const_iterator
Definition: disarray.h:300
void dis_entry_assembly(SetOp my_set_op=SetOp())
Definition: disarray.h:334
typename base::iterator iterator
Definition: disarray.h:299
void set_dis_entry(size_type dis_i, const U &val, const SetOp &set_op)
stash_traits< T, is_container >::map_type stash_map_type
Definition: disarray.h:418
const_reference dis_at(size_type dis_i) const
Definition: disarray.h:249
distributor::communicator_type communicator_type
Definition: disarray.h:229
void dis_entry_assembly_begin(SetOp=SetOp())
Definition: disarray.h:258
base::const_reference const_reference
Definition: disarray.h:226
const distributor & ownership() const
Definition: disarray.h:245
void dis_entry_assembly_end(SetOp=SetOp())
Definition: disarray.h:260
void repartition(const disarray_rep< size_type, sequential, A > &partition, disarray_rep< T, sequential, A > &new_disarray, disarray_rep< size_type, sequential, A > &old_numbering, disarray_rep< size_type, sequential, A > &new_numbering) const
Definition: disarray.h:261
reference dis_entry(size_type dis_i)
Definition: disarray.h:254
see the disarray page for the full documentation
Definition: disarray.h:497
disarray_rep< T, sequential, A > rep
Definition: disarray.h:500
rep::base::const_iterator const_iterator
Definition: disarray.h:503
rep::base::iterator iterator
Definition: disarray.h:502
rep::base::size_type size_type
Definition: disarray.h:501
see the distributor page for the full documentation
Definition: distributor.h:69
size_type last_index(size_type iproc) const
Definition: distributor.h:164
size_type dis_size() const
global and local sizes
Definition: distributor.h:214
communicator communicator_type
Definition: distributor.h:79
size_type first_index(size_type iproc) const
global index range and local size owned by ip-th process
Definition: distributor.h:158
const communicator_type & comm() const
Definition: distributor.h:152
idiststream: see the diststream page for the full documentation
Definition: diststream.h:336
odiststream: see the diststream page for the full documentation
Definition: diststream.h:137
see the smart_pointer page for the full documentation
distributed
Definition: asr.cc:228
rheolef::std value
#define trace_macro(message)
Definition: dis_macros.h:111
#define error_macro(message)
Definition: dis_macros.h:49
Expr1::float_type T
Definition: field_expr.h:230
verbose clean transpose logscale grid shrink ball stereo iso volume skipvtk deformation fastfieldload lattice reader_on_stdin color format format format format format format format format format format format format format format format format format format dump
This file is part of Rheolef.
std::istream & operator>>(std::istream &is, const catchmark &m)
Definition: catchmark.h:88
t operator()(const t &a, const t &b)
Definition: space.cc:386
std::ostream & operator<<(std::ostream &os, const catchmark &m)
Definition: catchmark.h:99
disarray element input helper
Definition: disarray.h:205
std::istream & operator()(std::istream &is, T &x) const
Definition: disarray.h:206
disarray element output helper
Definition: disarray.h:196
std::ostream & operator()(std::ostream &os, const T &x) const
Definition: disarray.h:197
std::ostream & operator()(std::ostream &os, const T &x) const
Definition: disarray.h:201
disarray_rep< T, distributed, A > & _x
Definition: disarray.h:482
disarray_dis_reference< T, A > & operator=(const disarray_dis_reference< T, A > &r)
Definition: disarray.h:456
disarray_dis_reference< T, A > & operator+=(const U &value)
Definition: disarray.h:468
disarray_dis_reference(disarray_rep< T, distributed, A > &x, size_type dis_i)
Definition: disarray.h:448
typename disarray_rep< T, distributed, A >::size_type size_type
Definition: disarray.h:446
disarray_dis_reference(const disarray_dis_reference< T, A > &r)
Definition: disarray.h:452
disarray_dis_reference< T, A > & operator-=(const U &value)
Definition: disarray.h:475
std::vector< std::pair< size_type, stash_value > > data
Definition: disarray.h:424
std::list< std::pair< size_type, mpi::request > > waits
Definition: disarray.h:423
std::pair< typename std::decay< T1 >::type, typename std::decay< T2 >::type > type
Definition: disarray.h:403
remove_const_in_pair< typename U::value_type >::type mapped_type
Definition: disarray.h:413
Expr1::memory_type M
Definition: vec_expr_v2.h:416