Distributed array storing the buffer on disk using temporary local files.
On construction, file and corresponding stream object are created and file is then closed. On destruction, file is deleted.
- Warning
- Only local operations will be currently supported, if RMA operations are requested, exception will be thrown.
- Examples
- LinearEigensystemDistrArrayExample.cpp, and OptimizeDistrArrayExample.cpp.
|
| | DistrArrayFile ()=delete |
| | returns local array boundaries and size
|
| |
| | DistrArrayFile (const DistrArrayFile &source) |
| |
| | DistrArrayFile (DistrArrayFile &&source) |
| |
| | DistrArrayFile (size_t dimension, MPI_Comm comm=molpro::mpi::comm_global(), const std::string &directory=".") |
| |
| | DistrArrayFile (std::unique_ptr< Distribution > distribution, MPI_Comm comm=molpro::mpi::comm_global(), const std::string &directory=".") |
| |
| | DistrArrayFile (const DistrArray &source) |
| |
| DistrArrayFile & | operator= (const DistrArrayFile &source)=delete |
| |
| DistrArrayFile & | operator= (DistrArrayFile &&source) noexcept |
| |
| | ~DistrArrayFile () override |
| |
| bool | compatible (const DistrArrayFile &source) const |
| |
| void | erase () override |
| | Dummy.
|
| |
| value_type | at (index_type ind) const override |
| |
| void | set (index_type ind, value_type val) override |
| | Writes value at a given index.
|
| |
| void | get (index_type lo, index_type hi, value_type *buf) const override |
| | Reads requested values.
|
| |
| std::vector< value_type > | get (index_type lo, index_type hi) const override |
| |
| void | put (index_type lo, index_type hi, const value_type *data) override |
| | Writes requested values to file.
|
| |
| void | acc (index_type lo, index_type hi, const value_type *data) override |
| |
| std::vector< value_type > | gather (const std::vector< index_type > &indices) const override |
| | gets elements with discontinuous indices from array. Blocking
|
| |
| void | scatter (const std::vector< index_type > &indices, const std::vector< value_type > &data) override |
| | array[indices[i]] = data[i] Puts vals of elements with discontinuous indices of array. Blocking.
|
| |
| void | scatter_acc (std::vector< index_type > &indices, const std::vector< value_type > &data) override |
| | array[indices[i]] += vals[i] Accumulates vals of elements into discontinuous indices of array. Atomic, blocking, with on-sided communication
|
| |
| std::vector< value_type > | vec () const override |
| | Copies the whole buffer into a vector. Blocking.
|
| |
| const Distribution & | distribution () const override |
| | Access distribution of the array among processes.
|
| |
| value_type | dot (const DistrArrayDisk &y) const |
| |
| void | set_buffer_size (size_t buffer_size) |
| |
| size_t | disk_page_size () const override |
| |
| std::unique_ptr< LocalBuffer > | local_buffer () override |
| | Not available: an array on disk is not held in memory.
|
| |
| std::unique_ptr< const LocalBuffer > | local_buffer () const override |
| | Not available: an array on disk is not held in memory.
|
| |
| virtual value_type | dot (const DistrArray &y) const |
| | Scalar product of two arrays. Collective. Throws error if any array is empty. Both arrays should be part of the same processor group (same communicator). The result is broadcast to each process.
|
| |
| virtual value_type | dot (const SparseArray &y) const |
| |
| virtual | ~DistrArray ()=default |
| |
| | DistrArray (const DistrArray &)=default |
| |
| | DistrArray (DistrArray &&) noexcept=default |
| |
| DistrArray & | operator= (const DistrArray &)=default |
| |
| DistrArray & | operator= (DistrArray &&) noexcept=default |
| |
| MPI_Comm | communicator () const |
| | return a copy of the communicator
|
| |
| virtual void | sync () const |
| | Synchronizes all process in this group and ensures any outstanding operations on the array have completed.
|
| |
| size_t | size () const |
| | total number of elements, same as overall dimension of array
|
| |
| bool | compatible (const DistrArray &other) const |
| | Checks that arrays are of the same dimensionality.
|
| |
| virtual void | zero () |
| | Set all local elements to zero.
|
| |
| virtual void | error (const std::string &message) const |
| | stops application with an error
|
| |
| value_type | operator[] (index_type ind) const |
| |
| util::ValueProxy< DistrArray > | operator[] (index_type ind) |
| |
| virtual void | fill (value_type val) |
| |
| virtual void | copy (const DistrArray &y) |
| |
| virtual void | copy_patch (const DistrArray &y, index_type start, index_type end) |
| | Copies elements in a patch of y. If both arrays are empty than does nothing. If only one is empty, throws an error.
|
| |
| virtual void | axpy (value_type a, const DistrArray &y) |
| | this[:] += a * y[:]. Throws an error if any array is empty. Add a multiple of another array to this one. Blocking, collective.
|
| |
| virtual void | axpy (value_type a, const SparseArray &y) |
| |
| virtual void | scal (value_type a) |
| | Scale by a constant. Local.
|
| |
| virtual void | add (const DistrArray &y) |
| | Add another array to this. Local. Throws error if any array is empty.
|
| |
| virtual void | add (value_type a) |
| | Add a constant. Local.
|
| |
| virtual void | sub (const DistrArray &y) |
| | Subtract another array from this. Local. Throws error if any array is empty.
|
| |
| virtual void | sub (value_type a) |
| | Subtract a constant. Local.
|
| |
| virtual void | recip () |
| | Take element-wise reciprocal of this. Local. No checks are made for zero values.
|
| |
| virtual void | times (const DistrArray &y) |
| | this[i] *= y[i]. Throws error if any array is empty.
|
| |
| virtual void | times (const DistrArray &y, const DistrArray &z) |
| | this[i] = y[i]*z[i]. Throws error if any array is empty.
|
| |
| void | divide (const DistrArray &y, const DistrArray &z, value_type shift=0, bool append=false, bool negative=false) |
| | this[i] = y[i]/(z[i]+shift). Collective. Throws error if any array is empty.
|
| |
| std::list< std::pair< index_type, value_type > > | min_n (int n) const |
| | returns n smallest elements in array x Collective operation, must be called by all processes in the group.
|
| |
| std::list< std::pair< index_type, value_type > > | max_n (int n) const |
| | returns n largest elements in array x Collective operation, must be called by all processes in the group.
|
| |
| std::list< std::pair< index_type, value_type > > | min_abs_n (int n) const |
| | returns n elements that are largest by absolute value in array x Collective operation, must be called by all processes in the group.
|
| |
| std::list< std::pair< index_type, value_type > > | max_abs_n (int n) const |
| | returns n elements that are largest by absolute value in array x Collective operation, must be called by all processes in the group.
|
| |
| std::vector< index_type > | min_loc_n (int n) const |
| | find the index of n smallest components in array x Collective operation, must be called by all processes in the group.
|
| |
| std::map< size_t, value_type > | select_max_dot (size_t n, const DistrArray &y) const |
| |
| std::map< size_t, value_type > | select_max_dot (size_t n, const SparseArray &y) const |
| |
| std::map< size_t, value_type > | select (size_t n, bool max=false, bool ignore_sign=false) const |
| |