1 #ifndef _RHEO_DISARRAY_H
2 #define _RHEO_DISARRAY_H
184 #include "rheolef/distributed.h"
185 #include "rheolef/distributor.h"
186 #include "rheolef/diststream.h"
187 #include "rheolef/heap_allocator.h"
188 #include "rheolef/msg_util.h"
189 #include "rheolef/container_traits.h"
190 #ifdef _RHEOLEF_HAVE_MPI
191 #include "rheolef/mpi_pair_datatype.h"
198 std::ostream&
operator() (std::ostream& os,
const T& x)
const {
return os << x; }
202 std::ostream&
operator() (std::ostream& os,
const T& x)
const {
return os << x <<
";"; }
207 std::istream&
operator() (std::istream& is,
T& x)
const {
return is >> x; }
217 template <
class T,
class A>
235 void resize (
const distributor& ownership,
const T& init_val =
T());
237 void resize (
size_type loc_size = 0,
const T& init_val =
T());
256 void get_dis_indexes (std::set<size_type>& ext_idx_set)
const;
258 template<class SetOp = typename default_set_op<T>::type>
260 template<class SetOp = typename default_set_op<T>::type>
268 error_macro (
"not yet");
271 void reverse_permutation (
274 idiststream& get_values (idiststream& s);
277 template <
class GetFunction> idiststream& get_values (idiststream& ips, GetFunction get_element);
287 #ifdef _RHEOLEF_HAVE_MPI
288 template <
class T,
class A>
297 typedef typename base::difference_type difference_type;
298 typedef typename base::reference reference;
299 typedef typename base::const_reference const_reference;
300 typedef typename base::iterator iterator;
304 typedef std::map <size_type, T> scatter_map_type;
306 struct dis_reference {
308 : _x(x), _dis_i(dis_i) {}
310 dis_reference& operator= (
const T&
value) {
311 _x.set_dis_entry (_dis_i,
value);
316 _x.set_add_dis_entry (_dis_i,
value);
327 disarray_rep (
const distributor& ownership,
const T& init_val =
T(),
const A& alloc = A());
328 void resize (
const distributor& ownership,
const T& init_val =
T());
329 disarray_rep (
const disarray_rep<T,distributed,A>& x);
331 A get_allocator()
const {
return base::get_allocator(); }
332 size_type size()
const {
return base::size(); }
333 const_iterator begin()
const {
return base::begin(); }
334 const_iterator end()
const {
return base::end(); }
335 iterator begin() {
return base::begin(); }
336 iterator end() {
return base::end(); }
338 const distributor& ownership()
const {
return base::_ownership; }
339 const mpi::communicator& comm()
const {
return ownership().comm(); }
340 size_type first_index ()
const {
return ownership().first_index(); }
341 size_type last_index ()
const {
return ownership().last_index(); }
342 size_type dis_size ()
const {
return ownership().dis_size(); }
344 dis_reference dis_entry (
size_type dis_i) {
return dis_reference (*
this, dis_i); }
346 template<class SetOp = typename default_set_op<T>::type>
347 void dis_entry_assembly_begin (SetOp my_set_op = SetOp());
348 template<class SetOp = typename default_set_op<T>::type>
349 void dis_entry_assembly_end (SetOp my_set_op = SetOp());
350 template<class SetOp = typename default_set_op<T>::type>
351 void dis_entry_assembly (SetOp my_set_op = SetOp())
352 { dis_entry_assembly_begin (my_set_op); dis_entry_assembly_end (my_set_op); }
354 template<
class Set,
class Map>
355 void append_dis_entry (
const Set& ext_idx_set, Map& ext_idx_map)
const;
357 template<
class Set,
class Map>
358 void get_dis_entry (
const Set& ext_idx_set, Map& ext_idx_map)
const {
360 append_dis_entry (ext_idx_set, ext_idx_map);
364 void append_dis_indexes (
const Set& ext_idx_set)
const { append_dis_entry (ext_idx_set, _ext_x); }
367 void set_dis_indexes (
const Set& ext_idx_set)
const { get_dis_entry (ext_idx_set, _ext_x); }
368 void get_dis_indexes (std::set<size_type>& ext_idx_set)
const;
369 void reset_dis_indexes()
const;
371 const_reference dis_at (
size_type dis_i)
const;
374 const scatter_map_type& get_dis_map_entries()
const {
return _ext_x; }
378 const disarray_rep<size_type,distributed,A2>& partition,
379 disarray_rep<T,distributed,A>& new_disarray,
380 disarray_rep<size_type,distributed,A2>& old_numbering,
381 disarray_rep<size_type,distributed,A2>& new_numbering)
const;
384 void permutation_apply (
385 const disarray_rep<size_type,distributed,A2>& new_numbering,
386 disarray_rep<T,distributed,A>& new_disarray)
const;
389 void reverse_permutation (
390 disarray_rep<size_type,distributed,A2>& inew2dis_iold)
const;
392 idiststream& get_values (idiststream& s);
393 odiststream& put_values (odiststream& s)
const;
394 odiststream& put_matlab (odiststream& s)
const;
395 template <
class GetFunction> idiststream& get_values (idiststream& ips, GetFunction get_element);
396 template <
class PutFunction> odiststream& put_values (odiststream& ops, PutFunction put_element)
const;
397 template <
class PutFunction,
class A2> odiststream& permuted_put_values (odiststream& ops,
const disarray_rep<size_type,distributed,A2>& perm,
398 PutFunction put_element)
const;
401 void set_dis_entry (
size_type dis_i,
const T& val);
403 void set_add_dis_entry (
size_type dis_i,
const U& val);
409 struct remove_const_in_pair {
412 template<
class T1,
class T2>
413 struct remove_const_in_pair<std::pair<T1,T2> > {
414 typedef std::pair<typename std::decay<T1>::type,
415 typename std::decay<T2>::type>
type;
417 template<
class U,
class IsContainer>
struct stash_traits {};
419 struct stash_traits<U,std::false_type> {
420 typedef U mapped_type;
421 typedef std::map <size_type, U> map_type;
424 struct stash_traits<U,std::true_type> {
425 typedef typename remove_const_in_pair<typename U::value_type>::type mapped_type;
426 typedef std::multimap <size_type, mapped_type> map_type;
428 typedef typename is_container_of_mpi_datatype<T>::type is_container;
429 typedef typename stash_traits<T,is_container>::mapped_type stash_value;
430 typedef typename stash_traits<T,is_container>::map_type stash_map_type;
434 struct message_type {
435 std::list<std::pair<size_type,mpi::request> > waits;
436 std::vector<std::pair<size_type,stash_value> > data;
437 message_type() : waits(), data() {}
441 template<
class Set,
class Map>
442 void append_dis_entry (
const Set& ext_idx_set, Map& ext_idx_map, std::true_type)
const;
443 template<
class Set,
class Map>
444 void append_dis_entry (
const Set& ext_idx_set, Map& ext_idx_map, std::false_type)
const;
447 stash_map_type _stash;
449 message_type _receive;
451 mutable scatter_map_type _ext_x;
458 template <
class T,
class M = rheo_default_memory_model,
class A = std::allocator<T> >
467 template <
class T,
class A>
490 void resize (
size_type loc_size = 0,
const T& init_val =
T());
492 void resize (
const distributor& ownership,
const T& init_val =
T());
516 template<class SetOp = typename default_set_op<T>::type>
518 template<class SetOp = typename default_set_op<T>::type>
520 template<class SetOp = typename default_set_op<T>::type>
527 void get_dis_indexes (std::set<size_type>& ext_idx_set)
const { base::data().get_dis_indexes (ext_idx_set); }
531 template<
class Set,
class Map>
void append_dis_entry (
const Set& ext_idx_set, Map& ext_idx_map)
const {}
532 template<
class Set,
class Map>
void get_dis_entry (
const Set& ext_idx_set, Map& ext_idx_map)
const {}
536 template<
class RepSize>
538 const RepSize& partition,
540 RepSize& old_numbering,
541 RepSize& new_numbering)
const
542 {
return base::data().repartition (partition, new_disarray, old_numbering, new_numbering); }
544 template<
class RepSize>
546 const RepSize& new_numbering,
548 {
return base::data().permutation_apply (new_numbering, new_disarray); }
552 { base::data().reverse_permutation (inew2dis_iold.data()); }
557 idiststream&
get_values (idiststream& ips) {
return base::data().get_values(ips); }
558 template <
class GetFunction>
559 idiststream&
get_values (idiststream& ips, GetFunction get_element) {
return base::data().get_values(ips, get_element); }
560 template <
class PutFunction>
564 template <
class T,
class A>
570 :
base(new_macro(
rep(loc_size,init_val,alloc)))
573 template <
class T,
class A>
579 :
base(new_macro(
rep(ownership,init_val,alloc)))
582 template <
class T,
class A>
589 base::data().resize (loc_size,init_val);
591 template <
class T,
class A>
598 base::data().resize (ownership,init_val);
600 #ifdef _RHEOLEF_HAVE_MPI
602 template <
class T,
class A>
620 typedef typename rep::scatter_map_type scatter_map_type;
629 A get_allocator()
const {
return base::data().get_allocator(); }
630 size_type size ()
const {
return base::data().size(); }
631 size_type dis_size ()
const {
return base::data().dis_size(); }
632 const distributor& ownership()
const {
return base::data().ownership(); }
633 const communicator& comm()
const {
return base::data().
comm(); }
635 reference operator[] (
size_type i) {
return base::data().operator[] (i); }
636 const_reference operator[] (
size_type i)
const {
return base::data().operator[] (i); }
637 reference operator() (
size_type i) {
return base::data().operator[] (i); }
638 const_reference operator() (
size_type i)
const {
return base::data().operator[] (i); }
640 iterator begin() {
return base::data().begin(); }
642 iterator end() {
return base::data().end(); }
647 template<
class Set,
class Map>
648 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); }
650 template<
class Set,
class Map>
651 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); }
654 void append_dis_indexes (
const Set& ext_idx_set)
const { base::data().append_dis_indexes (ext_idx_set); }
655 void reset_dis_indexes()
const { base::data().reset_dis_indexes(); }
656 void get_dis_indexes (std::set<size_type>& ext_idx_set)
const { base::data().get_dis_indexes (ext_idx_set); }
659 void set_dis_indexes (
const Set& ext_idx_set)
const { base::data().set_dis_indexes (ext_idx_set); }
661 const T& dis_at (
size_type dis_i)
const {
return base::data().dis_at (dis_i); }
664 const scatter_map_type& get_dis_map_entries()
const {
return base::data().get_dis_map_entries(); }
668 dis_reference dis_entry (
size_type dis_i) {
return base::data().dis_entry(dis_i); }
670 template<class SetOp = typename default_set_op<T>::type>
671 void dis_entry_assembly_begin (SetOp my_set_op = SetOp()) { base::data().dis_entry_assembly_begin (my_set_op); }
672 template<class SetOp = typename default_set_op<T>::type>
673 void dis_entry_assembly_end (SetOp my_set_op = SetOp()) { base::data().dis_entry_assembly_end (my_set_op); }
674 template<class SetOp = typename default_set_op<T>::type>
675 void dis_entry_assembly (SetOp my_set_op = SetOp()) { base::data().dis_entry_assembly (my_set_op); }
677 void dis_entry_assembly_begin() { base::data().template dis_entry_assembly_begin<typename default_set_op<T>::type>(); }
678 void dis_entry_assembly_end() { base::data().template dis_entry_assembly_end<typename default_set_op<T>::type>(); }
679 void dis_entry_assembly() { dis_entry_assembly_begin(); dis_entry_assembly_end(); }
683 template<
class RepSize>
685 const RepSize& partition,
686 disarray<T,distributed>& new_disarray,
687 RepSize& old_numbering,
688 RepSize& new_numbering)
const
689 {
return base::data().repartition (partition.data(), new_disarray.data(), old_numbering.data(), new_numbering.data()); }
691 template<
class RepSize>
692 void permutation_apply (
693 const RepSize& new_numbering,
694 disarray<T,distributed,A>& new_disarray)
const
695 { base::data().permutation_apply (new_numbering.data(), new_disarray.data()); }
697 void reverse_permutation (
698 disarray<size_type,distributed,A>& inew2dis_iold)
const
699 { base::data().reverse_permutation (inew2dis_iold.data()); }
703 odiststream& put_values (odiststream& ops)
const {
return base::data().put_values(ops); }
704 idiststream& get_values (idiststream& ips) {
return base::data().get_values(ips); }
705 void dump (std::string
name)
const {
return base::data().dump(
name); }
707 template <
class GetFunction>
708 idiststream& get_values (idiststream& ips, GetFunction get_element) {
return base::data().get_values(ips, get_element); }
709 template <
class PutFunction>
710 odiststream& put_values (odiststream& ops, PutFunction put_element)
const {
return base::data().put_values(ops, put_element); }
711 template <
class PutFunction,
class A2> odiststream& permuted_put_values (
712 odiststream& ops,
const disarray<size_type,distributed,A2>& perm, PutFunction put_element)
const
713 {
return base::data().permuted_put_values (ops, perm.data(), put_element); }
716 template <
class T,
class A>
718 disarray<T,distributed,A>::disarray (
719 const distributor& ownership,
722 : base(new_macro(rep(ownership,init_val,alloc)))
725 template <
class T,
class A>
728 disarray<T,distributed,A>::resize (
729 const distributor& ownership,
732 base::data().resize (ownership,init_val);
739 template <
class T,
class A>
746 template <
class T,
class A>
753 #ifdef _RHEOLEF_HAVE_MPI
754 template <
class T,
class A>
757 operator >> (idiststream& ips, disarray<T,distributed,A>& x)
759 return x.get_values(ips);
761 template <
class T,
class A>
764 operator << (odiststream& ops,
const disarray<T,distributed,A>& x)
766 return x.put_values(ops);
773 #include "rheolef/disarray_seq.icc"
774 #include "rheolef/disarray_mpi.icc"
field::size_type size_type
void dis_entry_assembly_end()
void reverse_permutation(disarray< size_type, sequential, A > &inew2dis_iold) const
idiststream & get_values(idiststream &ips, GetFunction get_element)
rep::const_iterator const_iterator
void get_dis_entry(const Set &ext_idx_set, Map &ext_idx_map) const
const_reference dis_at(size_type dis_i) const
void set_dis_indexes(const Set &ext_idx_set) const
rep::dis_reference dis_reference
disarray_rep< T, sequential, A > rep
const_iterator begin() const
size_type dis_size() const
void dis_entry_assembly()
void reset_dis_indexes() const
dis_reference dis_entry(size_type dis_i)
rep::difference_type difference_type
void dis_entry_assembly_begin()
rep::value_type value_type
void append_dis_indexes(const Set &ext_idx_set) const
void repartition(const RepSize &partition, disarray< T, sequential, A > &new_disarray, RepSize &old_numbering, RepSize &new_numbering) const
odiststream & put_values(odiststream &ops) const
void dis_entry_assembly_begin(SetOp my_set_op=SetOp())
const distributor & ownership() const
void permutation_apply(const RepSize &new_numbering, disarray< T, sequential, A > &new_disarray) const
odiststream & put_values(odiststream &ops, PutFunction put_element) const
smart_pointer< rep > base
rep::const_reference const_reference
idiststream & get_values(idiststream &ips)
void dis_entry_assembly_end(SetOp my_set_op=SetOp())
void get_dis_indexes(std::set< size_type > &ext_idx_set) const
void dis_entry_assembly(SetOp my_set_op=SetOp())
void dump(std::string name) const
const_iterator end() const
const communicator & comm() const
void append_dis_entry(const Set &ext_idx_set, Map &ext_idx_map) const
const_reference dis_at(size_type dis_i) const
distributor::communicator_type communicator_type
const_iterator begin() const
size_type dis_size() const
void reset_dis_indexes() const
void dis_entry_assembly_begin(SetOp=SetOp())
size_type first_index() const
base::size_type size_type
base::const_reference const_reference
const distributor & ownership() const
void dis_entry_assembly_end(SetOp=SetOp())
base::const_iterator const_iterator
A::difference_type difference_type
const_iterator end() const
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
base::reference reference
size_type last_index() const
reference dis_entry(size_type dis_i)
see the disarray page for the full documentation
disarray_rep< T, sequential, A > rep
rep::base::const_iterator const_iterator
rep::base::iterator iterator
rep::base::size_type size_type
see the distributor page for the full documentation
const communicator_type & comm() const
odiststream: see the diststream page for the full documentation
see the smart_pointer page for the full documentation
typename Expr1::memory_type memory_type
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)
std::ostream & operator<<(std::ostream &os, const catchmark &m)
std::enable_if< details::is_rheolef_arithmetic< U >::value,ad3_basic< T > & >::type operator+=(ad3_basic< T > &a, const U &b)
disarray element input helper
std::istream & operator()(std::istream &is, T &x) const
disarray element output helper
std::ostream & operator()(std::ostream &os, const T &x) const
std::ostream & operator()(std::ostream &os, const T &x) const