14 #ifndef SRC_MADNESS_WORLD_CLOUD_H_
15 #define SRC_MADNESS_WORLD_CLOUD_H_
33 template<
typename keyT>
44 for (
auto &l2 : list2.
list)
list.push_back(l2);
54 keyT key =
list.front();
78 template<
typename T, std::
size_t NDIM>
81 template<
typename T, std::
size_t NDIM>
84 template<
typename keyQ,
typename valueT>
87 template<
typename keyQ,
typename valueT>
90 template<
typename T, std::
size_t NDIM>
106 }
else if constexpr (std::is_pointer_v<T> &&
has_member_id<std::remove_pointer_t<T>>::value) {
110 std::size_t hashtype =
typeid(
T).hash_code();
150 bool is_replicated=
false;
152 bool force_load_from_cache =
false;
158 using valueT = std::vector<unsigned char>;
159 typedef std::map<keyT, cached_objT>
cacheT;
168 template <
typename T>
171 template <
typename T>
178 cache_reads(0l), cache_stores(0l) {
190 force_load_from_cache = value;
195 std::size_t memsize=0;
196 std::size_t max_record_size=0;
197 for (
auto& item : container) {
198 memsize+=item.second.size();
199 max_record_size=
std::max(max_record_size,item.second.size());
201 std::size_t global_memsize=memsize;
202 std::size_t max_memsize=memsize;
203 std::size_t min_memsize=memsize;
204 universe.
gop.
sum(global_memsize);
205 universe.
gop.
max(max_memsize);
206 universe.
gop.
max(max_record_size);
207 universe.
gop.
min(min_memsize);
209 auto local_size=container.size();
210 auto global_size=local_size;
211 universe.
gop.
sum(global_size);
212 double byte2gbyte=1.0/(1024*1024*1024);
214 if (universe.
rank()==0) {
215 print(
"Cloud memory:");
216 print(
" replicated:",is_replicated);
217 print(
"size of cloud (total)");
218 print(
" number of records: ",global_size);
219 print(
" memory in GBytes: ",global_memsize*byte2gbyte);
220 print(
"size of cloud (average per node)");
221 print(
" number of records: ",
double(global_size)/universe.
size());
222 print(
" memory in GBytes: ",global_memsize*byte2gbyte/universe.
size());
223 print(
"min/max of node");
224 print(
" memory in GBytes: ",min_memsize*byte2gbyte,max_memsize*byte2gbyte);
225 print(
" max record size in GBytes:",max_record_size*byte2gbyte);
231 double rtime = double(reading_time);
232 double wtime = double(writing_time);
233 double ptime = double(replication_time);
237 long creads = long(cache_reads);
238 long cstores = long(cache_stores);
240 universe.
gop.
sum(cstores);
241 if (universe.
rank() == 0) {
242 auto precision = std::cout.precision();
243 std::cout << std::fixed << std::setprecision(1);
244 print(
"cloud storing cpu time", wtime * 0.001);
245 print(
"cloud replication cpu time", ptime * 0.001);
246 print(
"cloud reading cpu time", rtime * 0.001, std::defaultfloat);
247 std::cout << std::setprecision(precision) << std::scientific;
248 print(
"cloud cache stores ",
long(cstores));
249 print(
"cloud cache loads ",
long(creads));
253 cached_objects.clear();
254 local_list_of_container_keys.
list.clear();
279 return forward_load<T>(world, rlist);
290 return load_tuple<T>(world, recordlist);
293 target.cloud_load(world, *
this, recordlist);
296 return do_load<T>(world, recordlist);
304 print(
"Cloud contents are replicated and read-only!");
315 recordlist+=store_tuple(world,
source);
317 recordlist+=
source.cloud_store(world,*
this);
319 recordlist+=store_other(world,
source);
333 std::list<keyT> keylist;
334 for (
auto it=container.
begin(); it!=container.
end(); ++it) {
335 keylist.push_back(it->first);
339 if (rank == world.
rank()) {
340 std::size_t keylistsize = keylist.size();
343 for (
auto key : keylist) {
345 bool found=container.
find(acc,key);
347 auto data = acc->second;
348 std::size_t sz=
data.size();
354 for (std::size_t start=0; start<sz; start+=chunk_size) {
355 std::size_t remainder = std::min(sz - start, chunk_size);
362 std::size_t keylistsize;
364 for (
size_t i=0; i<keylistsize; i++) {
371 for (std::size_t start=0; start<sz; start+=chunk_size) {
372 std::size_t remainder=std::min(sz-start,chunk_size);
385 mutable std::atomic<long> reading_time=0l;
386 mutable std::atomic<long> writing_time=0l;
387 mutable std::atomic<long> writing_time1=0l;
388 mutable std::atomic<long> replication_time=0l;
389 mutable std::atomic<long> cache_reads=0l;
390 mutable std::atomic<long> cache_stores=0l;
392 template<
typename>
struct is_tuple : std::false_type { };
393 template<
typename ...T>
struct is_tuple<
std::tuple<T...>> : std::true_type { };
395 template<
typename Q>
struct is_vector : std::false_type { };
396 template<
typename Q>
struct is_vector<
std::vector<Q>> : std::true_type { };
401 template<
typename T, std::
size_t NDIM>
417 long deltatime=long((
wall_time() - wall0) * 1000l);
424 const_cast<cacheT &
>(cached_objects).insert({record,std::make_any<T>(obj)});
430 if (world.
rank()==0) cache_reads++;
431 if (
debug)
print(
"loading",
typeid(
T).
name(),
"from cache record", record,
"to world", world.
id());
432 if (
auto obj = std::any_cast<T>(&cached_objects.find(record)->second))
return *obj;
439 return (cached_objects.count(key) == 1);
447 auto it = std::find(local_list_of_container_keys.
list.begin(),
448 local_list_of_container_keys.
list.end(), key);
449 return it!=local_list_of_container_keys.
list.end();
464 bool is_already_present= is_in_container(record);
466 if (is_already_present) std::cout <<
"skipping ";
468 std::cout <<
"storing world object of " <<
typeid(
T).
name() <<
"id " <<
source.id() <<
" to record " << record << std::endl;
470 std::cout <<
"storing object of " <<
typeid(
T).
name() <<
" to record " << record << std::endl;
474 if (is_already_present) {
475 if (world.
rank()==0) cache_stores++;
481 local_list_of_container_keys+=record;
493 typename std::enable_if<is_vector<T>::value,
T>
::type
495 std::size_t sz = do_load<std::size_t>(world, recordlist);
497 for (std::size_t i = 0; i < sz; ++i) {
498 target[i] = do_load<typename T::value_type>(world, recordlist);
508 typename std::enable_if<!is_vector<T>::value,
T>
::type
513 if (is_cached(record))
return load_from_cache<T>(world, record);
514 if (
debug)
print(
"loading",
typeid(
T).
name(),
"from container record", record,
"to world", world.
id());
529 std::cout <<
"storing " <<
typeid(
source).
name() <<
" of size " <<
source.size() << std::endl;
531 for (
const auto& s :
source) l += store_other(world, s);
533 if (
debug) std::cout <<
"done with vector storing; container size " << container.
size() << std::endl;
538 template<
typename... Ts>
541 auto storeaway = [&](
const auto &
arg) {
542 v += this->store(world,
arg);
544 auto l = [&](Ts
const &...
arg) {
545 ((storeaway(
arg)), ...);
557 if (
debug) std::cout <<
"loading tuple of type " <<
typeid(
T).
name() <<
" to world " << world.
id() << std::endl;
560 ((args = forward_load<
typename std::remove_reference<decltype(args)>
::type>(world, recordlist)), ...);
cloud class
Definition: cloud.h:147
bool is_cached(const keyT &key) const
Definition: cloud.h:438
void clear()
Definition: cloud.h:258
bool is_in_container(const keyT &key) const
checks if a (universe) container record is used
Definition: cloud.h:446
recordlistT store_other(madness::World &world, const std::vector< T > &source)
Definition: cloud.h:527
std::any cached_objT
Definition: cloud.h:156
recordlistT store(madness::World &world, const T &source)
Definition: cloud.h:302
T load_tuple(madness::World &world, recordlistT &recordlist) const
Definition: cloud.h:556
std::is_base_of< archive::ParallelSerializableObject, T > is_parallel_serializable_object
Definition: cloud.h:405
madness::archive::ContainerRecordOutputArchive::keyT keyT
Definition: cloud.h:157
Recordlist< keyT > recordlistT
Definition: cloud.h:160
std::is_constructible< T, World & > is_world_constructible
Definition: cloud.h:407
recordlistT store_other(madness::World &world, const T &source)
Definition: cloud.h:462
void set_force_load_from_cache(bool value)
Definition: cloud.h:189
decltype(std::declval< T >().cloud_store(std::declval< World & >(), std::declval< Cloud & >())) member_cloud_serialize_t
Definition: cloud.h:169
void replicate(const std::size_t chunk_size=INT_MAX)
Definition: cloud.h:325
recordlistT local_list_of_container_keys
Definition: cloud.h:165
void print_size(World &universe)
Definition: cloud.h:193
std::enable_if< is_vector< T >::value, T >::type do_load(World &world, recordlistT &recordlist) const
Definition: cloud.h:494
void clear_timings()
Definition: cloud.h:262
recordlistT store_tuple(World &world, const std::tuple< Ts... > &input)
store a tuple in multiple records
Definition: cloud.h:539
void set_debug(bool value)
Definition: cloud.h:181
T load(madness::World &world, const recordlistT recordlist) const
Definition: cloud.h:274
void cache(madness::World &world, const T &obj, const keyT &record) const
Definition: cloud.h:423
void set_fence(bool value)
Definition: cloud.h:185
Cloud(madness::World &universe)
Definition: cloud.h:177
cacheT cached_objects
Definition: cloud.h:164
void clear_cache(World &subworld)
Definition: cloud.h:252
T load_from_cache(madness::World &world, const keyT &record) const
load an object from the cache, record is unchanged
Definition: cloud.h:429
madness::meta::is_detected< member_cloud_serialize_t, T > has_cloud_serialize
Definition: cloud.h:172
std::vector< unsigned char > valueT
Definition: cloud.h:158
void print_timings(World &universe) const
Definition: cloud.h:230
T allocator(World &world) const
Definition: cloud.h:453
madness::WorldContainer< keyT, valueT > container
Definition: cloud.h:163
T forward_load(madness::World &world, recordlistT &recordlist) const
load a single object from the cloud, recordlist is consumed while loading elements
Definition: cloud.h:284
std::map< keyT, cached_objT > cacheT
Definition: cloud.h:159
std::enable_if<!is_vector< T >::value, T >::type do_load(World &world, recordlistT &recordlist) const
Definition: cloud.h:509
FunctionImpl holds all Function state to facilitate shallow copy semantics.
Definition: funcimpl.h:941
A multiresolution adaptive numerical function.
Definition: mra.h:122
A tensor is a multidimension array.
Definition: tensor.h:317
Makes a distributed container with specified attributes.
Definition: worlddc.h:866
bool find(accessor &acc, const keyT &key)
Write access to LOCAL value by key. Returns true if found, false otherwise (always false for remote).
Definition: worlddc.h:987
iterator begin()
Returns an iterator to the beginning of the local data (no communication)
Definition: worlddc.h:1070
void reset_pmap_to_local()
Returns shared pointer to the process mapping.
Definition: worlddc.h:1149
void replace(const pairT &datum)
Inserts/replaces key+value pair (non-blocking communication if key not local)
Definition: worlddc.h:974
iterator end()
Returns an iterator past the end of the local data (no communication)
Definition: worlddc.h:1084
World & get_world() const
Returns the world associated with this container.
Definition: worlddc.h:955
std::size_t size() const
Returns the number of local entries (no communication)
Definition: worlddc.h:1135
void clear()
Clears all local data (no communication)
Definition: worlddc.h:1128
void max(T *buf, size_t nelem)
Inplace global max while still processing AM & tasks.
Definition: worldgop.h:882
void fence(bool debug=false)
Synchronizes all processes in communicator AND globally ensures no pending AM or tasks.
Definition: worldgop.cc:161
void min(T *buf, size_t nelem)
Inplace global min while still processing AM & tasks.
Definition: worldgop.h:876
void sum(T *buf, size_t nelem)
Inplace global sum while still processing AM & tasks.
Definition: worldgop.h:870
void Bcast(T *buffer, int count, int root) const
MPI broadcast an array of count elements.
Definition: worldmpi.h:416
A parallel world class.
Definition: world.h:132
ProcessID rank() const
Returns the process rank in this World (same as MPI_Comm_rank()).
Definition: world.h:318
WorldMpiInterface & mpi
MPI interface.
Definition: world.h:202
ProcessID size() const
Returns the number of processes in this World (same as MPI_Comm_size()).
Definition: world.h:328
unsigned long id() const
Definition: world.h:313
WorldGopInterface & gop
Global operations.
Definition: world.h:205
Definition: parallel_dc_archive.h:14
long keyT
Definition: parallel_dc_archive.h:16
An archive for storing local or parallel data wrapping a BinaryFstreamOutputArchive.
Definition: parallel_archive.h:321
static bool debug
Definition: dirac-hatom.cc:16
Fcwf apply(World &world, real_convolution_3d &op, const Fcwf &psi)
Definition: fcwf.cc:281
auto T(World &world, response_space &f) -> response_space
Definition: global_functions.cc:34
Tensor< typename Tensor< T >::scalar_type > arg(const Tensor< T > &t)
Return a new tensor holding the argument of each element of t (complex types only)
Definition: tensor.h:2502
static const double v
Definition: hatom_sf_dirac.cc:20
#define max(a, b)
Definition: lda.h:51
#define MADNESS_CHECK(condition)
Check a condition — even in a release build the condition is always evaluated so it can have side eff...
Definition: madness_exception.h:190
#define MADNESS_EXCEPTION(msg, value)
Macro for throwing a MADNESS exception.
Definition: madness_exception.h:119
Definition: array_addons.h:50
File holds all helper structures necessary for the CC_Operator and CC2 class.
Definition: DFParameters.h:10
void hash_range(hashT &seed, It first, It last)
Definition: worldhash.h:280
void hash_combine(hashT &seed, const T &v)
Combine hash values.
Definition: worldhash.h:260
static class madness::twoscale_cache_class cache[kmax+1]
void print(const T &t, const Ts &... ts)
Print items to std::cout (items separated by spaces) and terminate with a new line.
Definition: print.h:225
double wall_time()
Returns the wall time in seconds relative to an arbitrary origin.
Definition: timers.cc:48
std::string type(const PairType &n)
Definition: PNOParameters.h:18
std::string name(const FuncType &type, const int ex=-1)
Definition: ccpairfunction.h:28
madness::hashT hash_value(const std::array< T, N > &a)
Hash std::array with madness hash.
Definition: array_addons.h:78
Definition: hatom_sf_dirac.cc:91
Definition: test_ccpairfunction.cc:22
std::atomic< long > & rtime
Definition: cloud.h:412
World & world
Definition: cloud.h:410
double wall0
Definition: cloud.h:411
~cloudtimer()
Definition: cloud.h:416
cloudtimer(World &world, std::atomic< long > &readtime)
Definition: cloud.h:414
static keyT compute_record(const std::vector< T > &arg)
Definition: cloud.h:94
keyT pop_front_and_return()
Definition: cloud.h:53
static keyT compute_record(const Function< T, NDIM > &arg)
Definition: cloud.h:79
friend std::ostream & operator<<(std::ostream &os, const Recordlist &arg)
Definition: cloud.h:117
Recordlist(const Recordlist &other)
Definition: cloud.h:41
Recordlist(const keyT &key)
Definition: cloud.h:39
static keyT compute_record(const std::shared_ptr< T > &arg)
Definition: cloud.h:100
Recordlist & operator+=(const Recordlist &list2)
Definition: cloud.h:43
static keyT compute_record(const T &arg)
Definition: cloud.h:103
std::size_t size() const
Definition: cloud.h:59
madness::meta::is_detected< member_id_t, T > has_member_id
Definition: cloud.h:69
decltype(std::declval< T >().id()) member_id_t
Definition: cloud.h:66
static keyT compute_record(const WorldContainer< keyQ, valueT > &arg)
Definition: cloud.h:85
decltype(std::declval< T >().hash()) member_hash_t
Definition: cloud.h:73
std::list< keyT > list
Definition: cloud.h:35
static keyT compute_record(const FunctionImpl< T, NDIM > *arg)
Definition: cloud.h:82
static keyT compute_record(const std::shared_ptr< WorldContainer< keyQ, valueT >> &arg)
Definition: cloud.h:88
static keyT compute_record(const Tensor< T > &arg)
Definition: cloud.h:97
Recordlist & operator+=(const keyT &key)
Definition: cloud.h:48
madness::meta::is_detected< member_hash_t, T > has_member_hash
Definition: cloud.h:76
static keyT compute_record(const std::shared_ptr< madness::FunctionImpl< T, NDIM >> &arg)
Definition: cloud.h:91
Recordlist()
Definition: cloud.h:37
#define MPI_BYTE
Definition: stubmpi.h:74
double source(const coordT &r)
Definition: testperiodic.cc:48
int ProcessID
Used to clearly identify process number/rank.
Definition: worldtypes.h:43
FLOAT target(const FLOAT &x)
Definition: y.cc:295