Homec4science
Diffusion LibMultiScale (features/new_parralelism) Browse

libmultiscale/src/common/ref_set.cc
f46e4477a0fcfeatures/new_parralelism

Last Change
Raw File

ref_set.cc
View Options

/**
* @file ref_set.cc
*
* @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
*
* @date Mon Sep 08 23:40:22 2014
*
* @brief This file contains the interface of containers of references 4 the
* migration system
*
* @section LICENSE
*
* Copyright (©) 2010-2011 EPFL (Ecole Polytechnique Fédérale de Lausanne)
* Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
*
* LibMultiScale is free software: you can redistribute it and/or modify it
* under the
* terms of the GNU Lesser General Public License as published by the Free
* Software Foundation, either version 3 of the License, or (at your option) any
* later version.
*
* LibMultiScale is distributed in the hope that it will be useful, but
* WITHOUT ANY
* WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
* A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
* details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with LibMultiScale. If not, see <http://www.gnu.org/licenses/>.
*
*/
/* -------------------------------------------------------------------------- */
#include <boost/preprocessor.hpp>
/* -------------------------------------------------------------------------- */
#include "lib_continuum.hh"
#include "lib_dd.hh"
#include "lib_md.hh"
#include "lm_common.hh"
#include "ref_set.hh"
#include "trace_atom.hh"
/* -------------------------------------------------------------------------- */
// #define PROC_INVALID -1
__BEGIN_LIBMULTISCALE__
/* -------------------------------------------------------------------------- */
// attach a vector of data to the set
template <typename Ref> void RefSet<Ref>::attachData(AttachedObject &obj) {
LM_ASSERT(std::find(attached.begin(), attached.end(), &obj) == attached.end(),
"obj " << &obj << " was alread attached in the past");
attached.push_back(&obj);
}
/* -------------------------------------------------------------------------- */
// detach a vector of data from the set
template <typename Ref> void RefSet<Ref>::detachData(AttachedObject &obj) {
UInt size = attached.size();
for (UInt i = 0; i < size; ++i) {
if (attached[i] == &obj) {
attached[i] = attached[size - 1];
attached.resize(size - 1);
break;
}
}
}
/* -------------------------------------------------------------------------- */
template <typename Ref>
void RefSet<Ref>::declareSentAtoms(MapRefToUInt &,
MapUIntToRefList &sent_reverse) {
DUMP("declare atoms sent for set " << name, DBG_INFO);
// clear maps
sent.clear();
sent_indexes.clear();
// loop over the sent atoms to build ordered buffer list
typename MapUIntToRefList::iterator it;
typename MapUIntToRefList::iterator end;
for (it = sent_reverse.begin(), end = sent_reverse.end(); it != end; ++it) {
UInt proc = (*it).first;
std::vector<Ref> &listsent = (*it).second;
for (UInt i = 0; i < listsent.size(); ++i) {
Ref at = listsent[i];
sent[proc].push_back(at);
sent_indexes[proc].push_back(at.getIndex());
}
}
{
typename MapUIntToRefList::iterator it2;
typename MapUIntToRefList::iterator end2;
for (it2 = sent.begin(), end2 = sent.end(); it2 != end2; ++it2) {
DUMP("I am supposed to send " << (*it2).second.size() << " atoms to proc "
<< (*it2).first << " for global set",
DBG_INFO);
}
}
}
/* -------------------------------------------------------------------------- */
template <typename Ref>
void RefSet<Ref>::declareRecvAtoms(MapUIntToRefList &recv_atoms) {
DUMP("declare atoms received for set " << name, DBG_INFO);
recv.clear();
recv_indexes.clear();
typename MapUIntToRefList::iterator it;
typename MapUIntToRefList::iterator end;
for (it = recv_atoms.begin(), end = recv_atoms.end(); it != end; ++it) {
UInt proc = (*it).first;
std::vector<Ref> &recvlist = (*it).second;
for (UInt i = 0; i < recvlist.size(); ++i) {
Ref at = recvlist[i];
recv[proc].push_back(at);
recv_indexes[proc].push_back(at.getIndex());
}
}
{
typename MapUIntToUIntList::iterator it2;
typename MapUIntToUIntList::iterator end2;
for (it2 = recv_indexes.begin(), end2 = recv_indexes.end(); it2 != end2;
++it2) {
DUMP("I am supposed to recv " << (*it2).second.size()
<< " atoms from proc " << (*it2).first
<< " for global set",
DBG_INFO);
}
}
}
/* -------------------------------------------------------------------------- */
template <typename Ref>
void RefSet<Ref>::packAttachedData(std::map<UInt, PackBuffer> &buffer) {
typename MapUIntToUIntList::iterator it;
typename MapUIntToUIntList::iterator end;
for (it = sent_indexes.begin(), end = sent_indexes.end(); it != end; ++it) {
UInt proc = (*it).first;
std::vector<UInt> listsent = (*it).second;
if (proc == UINT_MAX)
continue;
DUMP("list_sent size " << listsent.size(), DBG_INFO);
DUMP("attached_size " << attached.size(), DBG_INFO);
DUMP("will pack " << listsent.size() * attached.size() << " "
<< buffer[proc].size(),
DBG_INFO);
for (UInt i = 0; i < listsent.size(); ++i) {
for (UInt j = 0; j < attached.size(); ++j) {
attached[j]->packData(listsent[i], buffer[proc], proc);
}
}
}
}
/* -------------------------------------------------------------------------- */
template <typename Ref>
void RefSet<Ref>::unpackAttachedData(std::map<UInt, PackBuffer> &buffer) {
typename MapUIntToUIntList::iterator it;
typename MapUIntToUIntList::iterator end;
for (it = recv_indexes.begin(), end = recv_indexes.end(); it != end; ++it) {
UInt proc = (*it).first;
std::vector<UInt> listrecv = (*it).second;
if (proc == UINT_MAX)
continue;
DUMP("list_recv size " << listrecv.size(), DBG_INFO);
DUMP("attached_size " << attached.size(), DBG_INFO);
DUMP("will unpack " << listrecv.size() * attached.size() << " "
<< buffer[proc].remainingSize(),
DBG_INFO);
for (UInt i = 0; i < listrecv.size(); ++i) {
for (UInt j = 0; j < attached.size(); ++j) {
attached[j]->unpackData(listrecv[i], buffer[proc], proc);
}
}
}
}
/* -------------------------------------------------------------------------- */
template <typename Ref> void RefSet<Ref>::resize() {
UInt sz = container.size();
for (UInt j = 0; j < attached.size(); ++j) {
attached[j]->resize(sz);
}
}
/* -------------------------------------------------------------------------- */
template <typename Ref>
void RefSet<Ref>::moveAttachedValues(UInt i_src, UInt i_dest) {
if (i_src == i_dest)
return;
IF_REF_TRACED(container.get(i_src), "traced atom moved from index "
<< i_src << " to index " << i_dest
<< " for container " << &container);
DUMP("atom moved from index " << i_src << " to index " << i_dest
<< " for container " << &container,
DBG_INFO);
for (UInt j = 0; j < attached.size(); ++j) {
attached[j]->moveAttachedValues(i_src, i_dest);
}
}
/* -------------------------------------------------------------------------- */
#define DECLARE_REF_SET(n, data, obj) \
template class RefSet< \
ContainerArray<typename BOOST_PP_TUPLE_ELEM(3, 0, obj)::RefPoint>>; \
template class RefSet<typename BOOST_PP_TUPLE_ELEM(3, 0, \
obj)::ContainerPoints>;
BOOST_PP_SEQ_FOR_EACH(DECLARE_REF_SET, f, LIST_ATOM_MODEL)
BOOST_PP_SEQ_FOR_EACH(DECLARE_REF_SET, f, LIST_DD_MODEL)
BOOST_PP_SEQ_FOR_EACH(DECLARE_REF_SET, f, LIST_CONTINUUM_MODEL)
#undef DECLARE_REF_SET
__END_LIBMULTISCALE__
c4science · Help