SharedArray class.
More...
#include <sharedArray.h>
|
|
typedef std::vector< T >::const_iterator | const_iterator |
| |
|
typedef std::vector< T >::const_reverse_iterator | const_reverse_iterator |
| |
| enum | verify_type { VERIFY_UNINITIALIZED,
FE_VERIFY,
INIT_VERIFY,
NO_VERIFY
} |
| | Enum of verify types.
|
| |
|
|
static ImplementSerializable(SST::Shared::SharedObject) protected SharedObjectDataManager | manager |
| |
|
static constexpr uint32_t | NullClsId = std::numeric_limits<uint32_t>::max() |
| |
| enum | cxn_flag_t { ConstructorFlag
} |
| |
|
static void | serializable_abort (uint32_t line, const char *file, const char *func, const char *obj) |
| |
template<typename T>
class SST::Shared::SharedArray< T >
SharedArray class.
The class is templated to allow for an array of any non-pointer type. The type must be serializable.
◆ empty()
Tests if array is empty.
- Returns
- true if array is empty (size = 0), false otherwise
◆ initialize()
Initialize the SharedArray.
- Parameters
-
| obj_name | Name of the object. This name is how the object is uniquely identified across ranks. |
| length | Length of the array. The length can be 0 if no data is going to be written by the calling element, otherwise, it must be large enough to write the desired data. The final length of the array will be the maximum of the requested lengths. The length of the array can be queried using the size() method. |
| init_value | value that entries should be initialized to. By default, each array item will be initialized using the default constructor for the class being stored. |
| verify_mode | Specifies how multiply written data should be verified. FE_VERIFY uses a full/empty bit for each entry and if a value has previously been written, it will make sure the two values match. INIT_VERIFY will simply compare writes against the current value and will error unless the values aren't the same or the existing value is the init_value. When NO_VERIFY is passed, no verification will occur. This is mostly useful when you can guarantee that multiple elements won't write the same value and you want to do in-place modifications as you initialize. VERIFY_UNINITIALIZED is a reserved value and should not be passed. |
- Returns
- returns the number of instances that have intialized themselve before this instance on this MPI rank.
◆ isFullyPublished()
Check whether all instances of this SharedArray have called publish().
NOTE: Is is possible that this could return true one round, but false the next if a new instance of the SharedArray was initialized but not published after the last call.
◆ mutex_read()
Read data from the array.
This returns a const reference, so is read only. This version of read is always thread safe (
- See also
- operator[]).
- Parameters
-
- Returns
- const reference to data at index
◆ operator[]()
Read data from the array.
This returns a const reference, so is read only.
NOTE: This function does not use a mutex, so it is possible to get invalid results if another thread caused a resize of the underlying data structure at the same time as the read. However, after the init() phase of simulation is complete (in setup() and beyond), this is always a safe operation. If reading during init() and you can't guarantee that all elements have already written all data to the SharedArray, use mutex_read() to guarantee thread safety.
- Parameters
-
- Returns
- const reference to data at index
◆ publish()
Indicate that the calling element has written all the data it plans to write.
Writing to the array through this instance after publish() is called will create an error.
◆ size()
◆ write()
Write data to the array.
This function is thread-safe, as a mutex is used to ensure only one write at a time.
- Parameters
-
| index | index of the write |
| value | value to be written |
The documentation for this class was generated from the following file:
Public Types inherited from SST::Shared::SharedObject