40#ifndef SRC_MADNESS_MRA_MACROTASKQ_H_
41#define SRC_MADNESS_MRA_MACROTASKQ_H_
81 gaxpy(1.0, x, 1.0,
true);
86 void gaxpy(
const double a,
const T& right,
double b,
const bool fence=
true) {
93 template<
typename Archive>
115template<
typename T=
double>
133 void set_impl(
const std::shared_ptr<implT>& newimpl) {
142 void gaxpy(
const double a,
const T& right,
double b,
const bool fence=
true) {
143 impl->gaxpy(
a,right,
b,fence);
146 template<
typename Archive>
158 return impl->get_local();
166 std::vector<ScalarResult<T>>
v;
219template<
typename>
struct is_tuple : std::false_type { };
220template<
typename ...T>
struct is_tuple<
std::tuple<T...>> : std::true_type { };
223template<
typename tupleT, std::
size_t I>
226 typedef decay_tuple <tupleT> argtupleT;
228 if constexpr(
I >= std::tuple_size_v<tupleT>) {
232 using typeT =
typename std::tuple_element<I, argtupleT>::type;
233 if constexpr (not is_valid_task_result_v<typeT>) {
237 return check_tuple_is_valid_task_result<tupleT,I+1>();
247 left.
gaxpy(
a, right,
b, fence);
250template <
class Archive,
typename T>
253 bool exists=(ptr) ?
true :
false;
255 if (exists) ar & ptr->id();
260template <
class Archive,
typename T>
272 MADNESS_EXCEPTION(
"ScalarResultImpl: remote operation attempting to use a locally uninitialized object",0);
275 MADNESS_EXCEPTION(
"ScalarResultImpl<T> operation attempting to use an unregistered object",0);
316template<
typename T=
double>
328 typedef std::vector<std::shared_ptr<MacroTaskBase> >
taskqT;
349 printf(
"this is task with priority %4.1f\n",
priority);
352 print(
"nothing to print");
355 std::stringstream ss;
373template<
typename macrotaskT>
400 std::shared_ptr< WorldDCPmapInterface< Key<1> > >
pmap1;
401 std::shared_ptr< WorldDCPmapInterface< Key<2> > >
pmap2;
402 std::shared_ptr< WorldDCPmapInterface< Key<3> > >
pmap3;
403 std::shared_ptr< WorldDCPmapInterface< Key<4> > >
pmap4;
404 std::shared_ptr< WorldDCPmapInterface< Key<5> > >
pmap5;
405 std::shared_ptr< WorldDCPmapInterface< Key<6> > >
pmap6;
447 std::shared_ptr<World> all_worlds;
448 all_worlds.reset(
new World(comm));
460 print(
"number of tasks in taskq",
taskq.size());
461 print(
"redirecting output to files task.#####");
493 if (element<0)
break;
494 std::shared_ptr<MacroTaskBase>
task=
taskq[element];
501 tasktime+=(cpu1-cpu0);
502 if (
printdebug()) printf(
"completed task %3ld after %6.1fs at time %6.1fs\n",element,cpu1-cpu0,
wall_time());
505 const std::size_t ntask=
taskq.size();
507 auto in_percentile = [&ntask](
const long element) {
508 return std::floor(element/(0.1*(ntask+1)));
510 auto is_first_in_percentile = [&](
const long element) {
511 return (in_percentile(element)!=in_percentile(element-1));
514 std::cout << int(in_percentile(element)*10) <<
" " << std::flush;
528 printf(
"completed taskqueue after %4.1fs at time %4.1fs\n", cpu11 - cpu00,
wall_time());
529 printf(
" total cpu time / per world %4.1fs %4.1fs\n", tasktime, tasktime /
universe.
size());
549 for (
const auto& t : vtask) {
559 print(
"total number of tasks: ",
taskq.size());
560 print(
" task batch priority status");
561 for (
const auto& t :
taskq) t->print_me_as_table();
574 if (subworld.
rank()==0) {
588 auto is_Waiting = [](
const std::shared_ptr<MacroTaskBase>& mtb_ptr) {
return mtb_ptr->is_waiting();};
589 auto it=std::find_if(
taskq.begin(),
taskq.end(),is_Waiting);
590 if (it!=
taskq.end()) {
591 it->get()->set_running();
592 long element=it-
taskq.begin();
607 taskq[task_number]->set_complete();
627template<
typename taskT>
666 if (this->taskq_ptr==0) {
671 if (
debug) this->taskq_ptr->set_printlevel(20);
685 template<
typename ... Ts>
688 auto argtuple = std::tie(args...);
689 static_assert(std::is_same<
decltype(argtuple),
argtupleT>::value,
"type or number of arguments incorrect");
692 auto partitioner=
task.partitioner;
694 partitioner->set_nsubworld(
world.
size());
695 partitionT partition = partitioner->partition_tasks(argtuple);
698 print(
"MacroTask storage policy: ",
taskq_ptr->get_storage_policy());
699 print(
"Cloud storage policy: ",
taskq_ptr->cloud.get_storing_policy());
708 for (
const auto& batch_prio : partition) {
710 std::shared_ptr<MacroTaskBase>(
new MacroTaskInternal(
task, batch_prio, inputrecords, outputrecords)));
729 static_assert(check_tuple_is_valid_task_result<resultT,0>(),
730 "tuple has invalid result type in prepare_output_records");
732 static_assert(is_valid_task_result_v<resultT>,
"unknown result type in prepare_output_records");
735 if (
debug)
print(
"storing pointers to output in cloud");
737 auto store_output_records = [&](
const auto& result) {
739 typedef std::decay_t<
decltype(result)> argT;
741 outputrecords += cloud.
store(
world, result.get_impl().get());
745 outputrecords += cloud.
store(
world, result.get_impl());
749 std::vector<std::shared_ptr<typename argT::value_type::implT>>
v;
750 for (
const auto& ptr : result)
v.push_back(ptr.get_impl());
758 return outputrecords;
764 std::apply([&](
auto &&... args) {
765 (( outputrecords+=store_output_records(args) ), ...);
768 outputrecords=store_output_records(result);
770 return outputrecords;
783 if (
task.name==
"unknown_task")
return typeid(
task).
name();
791 static_assert(check_tuple_is_valid_task_result<resultT,0>(),
792 "tuple has invalid result type in prepare_output_records");
794 static_assert(is_valid_task_result_v<resultT>,
"unknown result type in prepare_output_records");
796 this->task.batch=batch_prio.first;
802 print(
"this is task",
get_name(),
"with batch",
task.batch,
"priority",this->get_priority());
806 std::stringstream ss;
808 std::size_t namesize=std::min(std::size_t(28),
name.size());
809 name += std::string(28-namesize,
' ');
811 std::stringstream ssbatch;
812 ssbatch <<
task.batch;
813 std::string strbatch=ssbatch.str();
814 int nspaces=std::max(
int(0),35-
int(ssbatch.str().size()));
815 strbatch+=std::string(nspaces,
' ');
818 << std::setw(10) << strbatch
824 template<
typename tupleT,
typename tupleR,
typename opT, std::
size_t I=0>
826 if constexpr(I < std::tuple_size_v<tupleT>) {
827 auto& element1=std::get<I>(tuple1);
828 auto& element2=std::get<I>(tuple2);
829 op(element1,element2);
830 binary_tuple_loop<tupleT, tupleR, opT, I+1>(tuple1,tuple2,
op);
834 template<
typename tupleT,
typename opT, std::
size_t I=0>
836 if constexpr(I < std::tuple_size_v<tupleT>) {
837 auto& element1=std::get<I>(tuple);
839 unary_tuple_loop<tupleT,opT, I+1>(tuple,
op);
844 template<
typename resultT1, std::
size_t I=0>
845 typename std::enable_if<is_tuple<resultT1>::value,
void>
::type
847 if constexpr(I < std::tuple_size_v<resultT1>) {
848 using elementT =
typename std::tuple_element<I, resultT>::type;
849 auto element_final=std::get<I>(final_result);
850 auto element_tmp=std::get<I>(tmp_result);
851 accumulate_into_final_result<elementT>(subworld, element_final, element_tmp, argtuple);
852 accumulate_into_final_result<resultT1,I+1>(subworld, final_result, tmp_result, argtuple);
857 template<
typename resultT1>
858 typename std::enable_if<not is_tuple<resultT1>::value,
void>
::type
863 result_tmp.change_tree_state(operating_state);
864 gaxpy(1.0,result,1.0, result_tmp);
871 gaxpy(1.0,result,1.0,result_tmp,
false);
875 gaxpy(1.0, result, 1.0, result_tmp.get_local(),
false);
879 std::size_t sz=result.size();
880 for (
int i=0; i<sz; ++i) {
881 gaxpy(1.0, result[i], 1.0, result_tmp[i].get_local(),
false);
892 argtupleT batched_argtuple =
task.batch.copy_input_batch(argtuple);
902 auto copi = [&](
auto&
arg) {
903 typedef std::decay_t<
decltype(
arg)> argT;
915 print(
"copied coefficients for task",
get_name(),
"in",cpu1-cpu0,
"seconds");
922 resultT result_batch = std::apply(
task, batched_argtuple);
924 constexpr std::size_t
bufsize=256;
926 std::snprintf(buffer,
bufsize,
"completed task %3ld after %6.1fs at time %6.1fs\n",element,cpu1-cpu0,
wall_time());
927 print(std::string(buffer));
930 auto insert_batch = [&](
auto& element1,
auto& element2) {
931 typedef std::decay_t<
decltype(element1)> decay_type;;
933 element1=
task.batch.insert_result_batch(element1,element2);
935 std::swap(element1,element2);
938 resultT result_subworld=
task.allocator(subworld,argtuple);
942 insert_batch(result_subworld,result_batch);
948 accumulate_into_final_result<resultT>(subworld, result_universe, result_subworld, argtuple);
950 }
catch (std::exception&
e) {
951 print(
"failing task no",element,
"in subworld",subworld.
id(),
"at time",
wall_time());
966 template<
typename T, std::
size_t NDIM>
973 template<
typename T, std::
size_t NDIM>
975 std::vector<Function<T,NDIM>> vresult;
976 vresult.resize(v_impl.size());
988 std::vector<ScalarResult<T>> vresult(v_sr_impl.size());
989 for (
auto i=0; i<v_sr_impl.size(); ++i) {
990 vresult[i].set_impl(v_sr_impl[i]);
1006 auto doit = [&](
auto& element) {
1007 typedef std::decay_t<
decltype(element)> elementT;
1011 typedef typename elementT::value_type::implT implT;
1012 auto ptr_element = cloud.
consuming_load<std::vector<std::shared_ptr<implT>>>(
1013 subworld, outputrecords1);
1017 typedef typename elementT::implT implT;
1018 auto ptr_element = cloud.
consuming_load<std::shared_ptr<implT>>(subworld, outputrecords1);
1022 typedef typename elementT::value_type ScalarResultT;
1023 typedef typename ScalarResultT::implT implT;
1024 typedef std::vector<std::shared_ptr<implT>> vptrT;
1025 auto ptr_element = cloud.
consuming_load<vptrT>(subworld, outputrecords1);
1031 auto ptr_element = cloud.
consuming_load<std::shared_ptr<typename elementT::implT>>(subworld, outputrecords1);
1039 static_assert(check_tuple_is_valid_task_result<resultT, 0>(),
1040 "invalid tuple task result -- must be vectors of functions");
Wrapper around MPI_Comm. Has a shallow copy constructor; use Create(Get_group()) for deep copy.
Definition safempi.h:490
Intracomm Split(int Color, int Key=0) const
Definition safempi.h:635
a batch consists of a 2D-input batch and a 1D-output batch: K-batch <- (I-batch, J-batch)
Definition macrotaskpartitioner.h:124
cloud class
Definition cloud.h:178
void clear()
Definition cloud.h:352
void replicate_per_node(const std::size_t chunk_size=INT_MAX)
Definition cloud.h:433
recordlistT store(madness::World &world, const T &source)
Definition cloud.h:410
Recordlist< keyT > recordlistT
Definition cloud.h:230
std::tuple< size_t, double > print_size(World &universe)
Definition cloud.h:279
void replicate(const std::size_t chunk_size=INT_MAX)
Definition cloud.h:441
T load(madness::World &world, const recordlistT recordlist) const
load a single object from the cloud, recordlist is kept unchanged
Definition cloud.h:370
ReplicationPolicy get_replication_policy() const
Definition cloud.h:267
void clear_cache(World &subworld)
Definition cloud.h:346
@ NodeReplicated
Definition cloud.h:216
@ Distributed
Definition cloud.h:212
@ RankReplicated
Definition cloud.h:214
void print_timings(World &universe) const
Definition cloud.h:317
StoragePolicy
Definition cloud.h:204
@ StoreFunctionPointer
Definition cloud.h:207
@ StoreFunction
Definition cloud.h:205
T consuming_load(madness::World &world, recordlistT &recordlist) const
similar to load, but will consume the recordlist
Definition cloud.h:383
static void set_default_pmap(World &world)
Sets the default process map.
Definition mraimpl.h:3548
static std::shared_ptr< WorldDCPmapInterface< Key< NDIM > > > & get_pmap()
Returns the default process map.
Definition funcdefaults.h:389
static void set_pmap(const std::shared_ptr< WorldDCPmapInterface< Key< NDIM > > > &value)
Sets the default process map (does not redistribute existing functions)
Definition funcdefaults.h:405
FunctionImpl holds all Function state to facilitate shallow copy semantics.
Definition funcimpl.h:945
A multiresolution adaptive numerical function.
Definition mra.h:139
void set_impl(const std::shared_ptr< FunctionImpl< T, NDIM > > &impl)
Replace current FunctionImpl with provided new one.
Definition mra.h:661
A future is a possibly yet unevaluated value.
Definition future.h:373
T & get(bool dowork=true) &
Gets the value, waiting if necessary.
Definition future.h:574
base class
Definition macrotaskq.h:325
void set_running()
Definition macrotaskq.h:337
virtual ~MacroTaskBase()
Definition macrotaskq.h:331
void set_waiting()
Definition macrotaskq.h:338
MacroTaskBase()
Definition macrotaskq.h:330
virtual void print_me(std::string s="") const
Definition macrotaskq.h:348
std::string print_priority_and_status_to_string() const
Definition macrotaskq.h:354
void set_complete()
Definition macrotaskq.h:336
double priority
Definition macrotaskq.h:333
bool is_complete() const
Definition macrotaskq.h:340
Status
Definition macrotaskq.h:334
@ Complete
Definition macrotaskq.h:334
@ Running
Definition macrotaskq.h:334
@ Unknown
Definition macrotaskq.h:334
@ Waiting
Definition macrotaskq.h:334
bool is_running() const
Definition macrotaskq.h:341
enum madness::MacroTaskBase::Status stat
virtual void run(World &world, Cloud &cloud, taskqT &taskq, const long element, const bool debug, const MacroTaskInfo::StoragePolicy storage_policy)=0
double get_priority() const
Definition macrotaskq.h:360
void set_priority(const double p)
Definition macrotaskq.h:361
virtual void print_me_as_table(std::string s="") const
Definition macrotaskq.h:351
std::vector< std::shared_ptr< MacroTaskBase > > taskqT
Definition macrotaskq.h:328
friend std::ostream & operator<<(std::ostream &os, const MacroTaskBase::Status s)
Definition macrotaskq.h:363
bool is_waiting() const
Definition macrotaskq.h:342
Definition macrotaskq.h:1062
MacroTaskOperationBase()
Definition macrotaskq.h:1067
Batch batch
Definition macrotaskq.h:1064
std::shared_ptr< MacroTaskPartitioner > partitioner
Definition macrotaskq.h:1066
std::string name
Definition macrotaskq.h:1065
partition one (two) vectors into 1D (2D) batches.
Definition macrotaskpartitioner.h:182
std::list< std::pair< Batch, double > > partitionT
Definition macrotaskpartitioner.h:186
Definition macrotaskq.h:387
long nsubworld
Definition macrotaskq.h:394
std::mutex taskq_mutex
Definition macrotaskq.h:392
bool printdebug() const
Definition macrotaskq.h:407
static void set_pmap(World &world)
Definition macrotaskq.h:611
MacroTaskInfo::StoragePolicy get_storage_policy() const
Definition macrotaskq.h:419
bool printtimings_detail() const
Definition macrotaskq.h:410
void run_all()
run all tasks
Definition macrotaskq.h:455
void set_complete(const long task_number) const
scheduler is located on rank==0
Definition macrotaskq.h:600
MacroTaskQ(World &universe, int nworld, const MacroTaskInfo::StoragePolicy sp, const long printlevel=0)
create an empty taskq and initialize the subworlds
Definition macrotaskq.h:424
World & universe
Definition macrotaskq.h:389
std::shared_ptr< WorldDCPmapInterface< Key< 1 > > > pmap1
set the process map for the subworld
Definition macrotaskq.h:400
std::shared_ptr< WorldDCPmapInterface< Key< 3 > > > pmap3
Definition macrotaskq.h:402
MacroTaskBase::taskqT taskq
Definition macrotaskq.h:391
void add_tasks(MacroTaskBase::taskqT &vtask)
Definition macrotaskq.h:548
long get_scheduled_task_number(World &subworld)
scheduler is located on universe.rank==0
Definition macrotaskq.h:572
void set_complete_local(const long task_number) const
scheduler is located on rank==0
Definition macrotaskq.h:605
World & get_subworld()
Definition macrotaskq.h:415
std::shared_ptr< WorldDCPmapInterface< Key< 4 > > > pmap4
Definition macrotaskq.h:403
std::size_t size() const
Definition macrotaskq.h:620
std::shared_ptr< WorldDCPmapInterface< Key< 5 > > > pmap5
Definition macrotaskq.h:404
void print_taskq() const
Definition macrotaskq.h:555
std::shared_ptr< World > subworld_ptr
Definition macrotaskq.h:390
bool printtimings() const
Definition macrotaskq.h:409
std::shared_ptr< WorldDCPmapInterface< Key< 2 > > > pmap2
Definition macrotaskq.h:401
bool printprogress() const
Definition macrotaskq.h:408
std::shared_ptr< WorldDCPmapInterface< Key< 6 > > > pmap6
Definition macrotaskq.h:405
void set_printlevel(const long p)
Definition macrotaskq.h:417
long printlevel
Definition macrotaskq.h:393
madness::Cloud cloud
Definition macrotaskq.h:414
long get_nsubworld() const
Definition macrotaskq.h:416
void add_replicated_task(const std::shared_ptr< MacroTaskBase > &task)
Definition macrotaskq.h:567
~MacroTaskQ()
Definition macrotaskq.h:438
static std::shared_ptr< World > create_worlds(World &universe, const std::size_t nsubworld)
Definition macrotaskq.h:442
const MacroTaskInfo::StoragePolicy storage_policy
storage policy for the taskq can be set only once at construction
Definition macrotaskq.h:397
long get_scheduled_task_number_local()
Definition macrotaskq.h:584
Definition macrotaskq.h:774
taskT task
Definition macrotaskq.h:781
MacroTaskInternal(const taskT &task, const std::pair< Batch, double > &batch_prio, const recordlistT &inputrecords, const recordlistT &outputrecords)
Definition macrotaskq.h:787
std::enable_if< notis_tuple< resultT1 >::value, void >::type accumulate_into_final_result(World &subworld, resultT1 &result, const resultT1 &result_tmp, const argtupleT &argtuple)
accumulate the result of the task into the final result living in the universe
Definition macrotaskq.h:859
resultT get_output(World &subworld, Cloud &cloud) const
return the WorldObjects or the result functions living in the universe
Definition macrotaskq.h:999
static ScalarResult< T > pointer2WorldObject(const std::shared_ptr< ScalarResultImpl< T > > sr_impl)
Definition macrotaskq.h:982
decay_tuple< typename taskT::argtupleT > argtupleT
Definition macrotaskq.h:776
static std::vector< Function< T, NDIM > > pointer2WorldObject(const std::vector< std::shared_ptr< FunctionImpl< T, NDIM > > > v_impl)
Definition macrotaskq.h:974
void cleanup() override
Definition macrotaskq.h:961
taskT::resultT resultT
Definition macrotaskq.h:777
recordlistT outputrecords
Definition macrotaskq.h:779
std::string get_name() const
Definition macrotaskq.h:782
void binary_tuple_loop(tupleT &tuple1, tupleR &tuple2, opT &op) const
loop over the tuple elements of both tuples and execute the operation op on each element pair
Definition macrotaskq.h:825
static Function< T, NDIM > pointer2WorldObject(const std::shared_ptr< FunctionImpl< T, NDIM > > impl)
Definition macrotaskq.h:967
static std::vector< ScalarResult< T > > pointer2WorldObject(const std::vector< std::shared_ptr< ScalarResultImpl< T > > > v_sr_impl)
Definition macrotaskq.h:987
void print_me_as_table(std::string s="") const override
Definition macrotaskq.h:805
void print_me(std::string s="") const override
Definition macrotaskq.h:801
void run(World &subworld, Cloud &cloud, MacroTaskBase::taskqT &taskq, const long element, const bool debug, const MacroTaskInfo::StoragePolicy storage_policy) override
called by the MacroTaskQ when the task is scheduled
Definition macrotaskq.h:888
void unary_tuple_loop(tupleT &tuple, opT &op) const
Definition macrotaskq.h:835
std::enable_if< is_tuple< resultT1 >::value, void >::type accumulate_into_final_result(World &subworld, resultT1 &final_result, const resultT1 &tmp_result, const argtupleT &argtuple)
accumulate the result of the task into the final result living in the universe
Definition macrotaskq.h:846
recordlistT inputrecords
Definition macrotaskq.h:778
Definition macrotaskq.h:628
MacroTask & set_debug(const bool value)
Definition macrotaskq.h:676
MacroTask(World &world, taskT &task)
constructor takes the task, but no arguments to the task
Definition macrotaskq.h:649
taskT::resultT resultT
Definition macrotaskq.h:638
std::shared_ptr< MacroTaskQ > taskq_ptr
Definition macrotaskq.h:722
taskT::argtupleT argtupleT
Definition macrotaskq.h:639
bool immediate_execution
Definition macrotaskq.h:643
World & world
Definition macrotaskq.h:721
MacroTask(World &world, taskT &task, MacroTaskInfo::StoragePolicy storage_policy)
constructor takes task and the storage policy, but no arguments to the task
Definition macrotaskq.h:655
resultT operator()(const Ts &... args)
this mimicks the original call to the task functor, called from the universe
Definition macrotaskq.h:686
bool debug
Definition macrotaskq.h:642
taskT task
Definition macrotaskq.h:641
MacroTaskPartitioner::partitionT partitionT
Definition macrotaskq.h:629
Cloud::recordlistT recordlistT
Definition macrotaskq.h:640
recordlistT prepare_output_records(Cloud &cloud, resultT &result)
store pointers to the result WorldObject in the cloud and return the recordlist
Definition macrotaskq.h:727
MacroTask(World &world, taskT &task, std::shared_ptr< MacroTaskQ > taskq_ptr)
constructor takes the task,
Definition macrotaskq.h:661
static void measure_and_print(World &world)
measure the memory usage of all objects of all worlds
Definition memory_measurement.h:21
helper class for returning the result of a task, which is not a madness Function, but a simple scalar
Definition macrotaskq.h:55
void gaxpy(const double a, const T &right, double b, const bool fence=true)
accumulate, optional fence
Definition macrotaskq.h:86
void serialize(Archive &ar)
Definition macrotaskq.h:94
T get()
after completion of the taskq get the final value
Definition macrotaskq.h:99
ScalarResultImpl< T > & operator=(const T &x)
simple assignment of the scalar value
Definition macrotaskq.h:75
ScalarResultImpl(const ScalarResultImpl &other)=delete
Disable the default copy constructor.
ScalarResultImpl< T > & operator=(const ScalarResultImpl< T > &other)=delete
disable assignment operator
ScalarResultImpl< T > & operator+=(const T &x)
Definition macrotaskq.h:80
~ScalarResultImpl()
Definition macrotaskq.h:69
T value
the scalar value
Definition macrotaskq.h:112
T get_local() const
Definition macrotaskq.h:106
T value_type
Definition macrotaskq.h:57
ScalarResultImpl(World &world)
Definition macrotaskq.h:58
Definition macrotaskq.h:116
void serialize(Archive &ar)
Definition macrotaskq.h:147
ScalarResult(const std::shared_ptr< implT > &impl)
Definition macrotaskq.h:123
void gaxpy(const double a, const T &right, double b, const bool fence=true)
accumulate, optional fence
Definition macrotaskq.h:142
ScalarResultImpl< T > implT
Definition macrotaskq.h:118
T get()
after completion of the taskq get the final value
Definition macrotaskq.h:152
ScalarResult(World &world)
Definition macrotaskq.h:122
std::shared_ptr< implT > impl
Definition macrotaskq.h:119
ScalarResult & operator=(const T &x)
Definition macrotaskq.h:124
std::shared_ptr< implT > get_impl() const
Definition macrotaskq.h:129
void set_impl(const std::shared_ptr< implT > &newimpl)
Definition macrotaskq.h:133
T get_local() const
after completion of the taskq get the final value
Definition macrotaskq.h:157
uniqueidT id() const
Definition macrotaskq.h:137
void broadcast_serializable(objT &obj, ProcessID root)
Broadcast a serializable object.
Definition worldgop.h:756
void fence(bool debug=false)
Synchronizes all processes in communicator AND globally ensures no pending AM or tasks.
Definition worldgop.cc:161
bool set_forbid_fence(bool value)
Set forbid_fence flag to new value and return old value.
Definition worldgop.h:676
void sum(T *buf, size_t nelem)
Inplace global sum while still processing AM & tasks.
Definition worldgop.h:872
SafeMPI::Intracomm & comm()
Returns the associated SafeMPI communicator.
Definition worldmpi.h:286
Implements most parts of a globally addressable object (via unique ID).
Definition world_object.h:364
World & get_world() const
Returns a reference to the world.
Definition world_object.h:717
World & world
The World this object belongs to. (Think globally, act locally).
Definition world_object.h:381
void process_pending()
To be called from derived constructor to process pending messages.
Definition world_object.h:656
detail::task_result_type< memfnT >::futureT send(ProcessID dest, memfnT memfn) const
Definition world_object.h:731
detail::task_result_type< memfnT >::futureT task(ProcessID dest, memfnT memfn, const TaskAttributes &attr=TaskAttributes()) const
Sends task to derived class method returnT (this->*memfn)().
Definition world_object.h:1005
A parallel world class.
Definition world.h:132
static World * world_from_id(std::uint64_t id)
Convert a World ID to a World pointer.
Definition world.h:492
ProcessID rank() const
Returns the process rank in this World (same as MPI_Comm_rank()).
Definition world.h:320
WorldMpiInterface & mpi
MPI interface.
Definition world.h:204
ProcessID size() const
Returns the number of processes in this World (same as MPI_Comm_size()).
Definition world.h:330
unsigned long id() const
Definition world.h:315
WorldGopInterface & gop
Global operations.
Definition world.h:207
std::optional< T * > ptr_from_id(uniqueidT id) const
Look up a local pointer from a world-wide unique ID.
Definition world.h:416
Class for unique global IDs.
Definition uniqueid.h:53
Declares the Cloud class for storing data and transfering them between worlds.
char * p(char *buf, const char *name, int k, int initial_level, double thresh, int order)
Definition derivatives.cc:72
const std::size_t bufsize
Definition derivatives.cc:16
static bool debug
Definition dirac-hatom.cc:16
auto T(World &world, response_space &f) -> response_space
Definition global_functions.cc:28
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:2503
static const double v
Definition hatom_sf_dirac.cc:20
Tensor< double > op(const Tensor< double > &x)
Definition kain.cc:508
#define MADNESS_EXCEPTION(msg, value)
Macro for throwing a MADNESS exception.
Definition madness_exception.h:119
#define MADNESS_ASSERT(condition)
Assert a condition that should be free of side-effects since in release builds this might be a no-op.
Definition madness_exception.h:134
Namespace for all elements and tools of MADNESS.
Definition DFParameters.h:10
std::vector< ScalarResult< T > > scalar_result_vector(World &world, std::size_t n)
helper function to create a vector of ScalarResultImpl, circumventing problems with the constructors
Definition macrotaskq.h:165
std::ostream & operator<<(std::ostream &os, const particle< PDIM > &p)
Definition lowrankfunction.h:401
static double cpu_time()
Returns the cpu time in seconds relative to an arbitrary origin.
Definition timers.h:127
void set_impl(std::vector< Function< T, NDIM > > &v, const std::vector< std::shared_ptr< FunctionImpl< T, NDIM > > > vimpl)
Definition vmra.h:688
std::vector< std::shared_ptr< FunctionImpl< T, NDIM > > > get_impl(const std::vector< Function< T, NDIM > > &v)
Definition vmra.h:681
TreeState
Definition funcdefaults.h:59
@ reconstructed
s coeffs at the leaves only
Definition funcdefaults.h:60
@ compressed
d coeffs in internal nodes, s and d coeffs at the root
Definition funcdefaults.h:61
constexpr bool check_tuple_is_valid_task_result()
given a tuple check recursively if all elements are valid task results
Definition macrotaskq.h:224
static const Slice _(0,-1, 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:226
@ TT_FULL
Definition gentensor.h:120
NDIM & f
Definition mra.h:2498
constexpr bool is_valid_task_result_v
check if type is a valid task result: it must be a WorldObject and must implement gaxpy
Definition macrotaskq.h:210
const Function< T, NDIM > & change_tree_state(const Function< T, NDIM > &f, const TreeState finalstate, bool fence=true)
change tree state of a function
Definition mra.h:2824
decltype(decay_types(std::declval< T >())) decay_tuple
Definition macrotaskpartitioner.h:22
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
Function< T, NDIM > copy(const Function< T, NDIM > &f, const std::shared_ptr< WorldDCPmapInterface< Key< NDIM > > > &pmap, bool fence=true)
Create a new copy of the function with different distribution and optional fence.
Definition mra.h:2066
void gaxpy(const double a, ScalarResult< T > &left, const double b, const T &right, const bool fence=true)
the result type of a macrotask must implement gaxpy
Definition macrotaskq.h:246
static const double b
Definition nonlinschro.cc:119
static const double a
Definition nonlinschro.cc:118
Definition macrotaskq.h:282
StoragePolicy
Definition macrotaskq.h:283
@ StoreFunction
store a madness function in the cloud – can have a large memory impact
Definition macrotaskq.h:284
@ StorePointerToFunction
Definition macrotaskq.h:285
@ StoreFunctionViaPointer
coefficients to the subworlds when the task is started. This is the default policy.
Definition macrotaskq.h:288
static MacroTaskInfo::StoragePolicy default_storage_policy
declaration here, definition in mra1.cc
Definition macrotaskq.h:310
static Cloud::StoragePolicy to_cloud_storage_policy(MacroTaskInfo::StoragePolicy policy)
given the MacroTask's storage policy return the corresponding Cloud storage policy
Definition macrotaskq.h:292
static void set_default(MacroTaskInfo::StoragePolicy sp)
Definition macrotaskq.h:305
static MacroTaskInfo::StoragePolicy get_default()
Definition macrotaskq.h:301
Definition macrotaskq.h:632
Default load of an object via serialize(ar, t).
Definition archive.h:667
Default store of an object via serialize(ar, t).
Definition archive.h:612
class to temporarily redirect output to cout
Definition print.h:277
RAII class to redirect cout to a file.
Definition print.h:251
Definition macrotaskq.h:195
Definition macrotaskq.h:180
Definition macrotaskq.h:174
Definition macrotaskq.h:201
Definition macrotaskq.h:189
Definition macrotaskq.h:219
static void load(const Archive &ar, std::shared_ptr< ScalarResultImpl< T > > &ptr)
Definition macrotaskq.h:262
static void store(const Archive &ar, const std::shared_ptr< ScalarResultImpl< T > > &ptr)
Definition macrotaskq.h:252
static const double_complex I
Definition tdse1d.cc:164
void doit(World &world)
Definition tdse.cc:921
void e()
Definition test_sig.cc:75
Declares the World class for the parallel runtime environment.
int ProcessID
Used to clearly identify process number/rank.
Definition worldtypes.h:43