.TH "fi_atomic" "3" "2017\-02\-16" "Libfabric Programmer\[aq]s Manual" "\@VERSION\@"
.SH NAME
.PP
fi_atomic \- Remote atomic functions
.PP
fi_atomic / fi_atomicv / fi_atomicmsg / fi_inject_atomic : Initiates an
atomic operation to remote memory
.PP
fi_fetch_atomic / fi_fetch_atomicv / fi_fetch_atomicmsg : Initiates an
atomic operation to remote memory, retrieving the initial value.
.PP
fi_compare_atomic / fi_compare_atomicv / fi_compare_atomicmsg :
Initiates an atomic compare\-operation to remote memory, retrieving the
initial value.
.PP
fi_atomicvalid / fi_fetch_atomicvalid / fi_compare_atomicvalid /
fi_query_atomic : Indicates if a provider supports a specific atomic
operation
.SH SYNOPSIS
.IP
.nf
\f[C]
#include\ <rdma/fi_atomic.h>

ssize_t\ fi_atomic(struct\ fid_ep\ *ep,\ const\ void\ *buf,
\ \ \ \ size_t\ count,\ void\ *desc,\ fi_addr_t\ dest_addr,
\ \ \ \ uint64_t\ addr,\ uint64_t\ key,
\ \ \ \ enum\ fi_datatype\ datatype,\ enum\ fi_op\ op,\ void\ *context);

ssize_t\ fi_atomicv(struct\ fid_ep\ *ep,\ const\ struct\ fi_ioc\ *iov,
\ \ \ \ void\ **desc,\ size_t\ count,\ fi_addr_t\ dest_addr,
\ \ \ \ uint64_t\ addr,\ uint64_t\ key,
\ \ \ \ enum\ fi_datatype\ datatype,\ enum\ fi_op\ op,\ void\ *context);

ssize_t\ fi_atomicmsg(struct\ fid_ep\ *ep,\ const\ struct\ fi_msg_atomic\ *msg,
\ \ \ \ uint64_t\ flags);

ssize_t\ fi_inject_atomic(struct\ fid_ep\ *ep,\ const\ void\ *buf,
\ \ \ \ size_t\ count,\ fi_addr_t\ dest_addr,
\ \ \ \ uint64_t\ addr,\ uint64_t\ key,
\ \ \ \ enum\ fi_datatype\ datatype,\ enum\ fi_op\ op);

ssize_t\ fi_fetch_atomic(struct\ fid_ep\ *ep,\ const\ void\ *buf,
\ \ \ \ size_t\ count,\ void\ *desc,\ void\ *result,\ void\ *result_desc,
\ \ \ \ fi_addr_t\ dest_addr,\ uint64_t\ addr,\ uint64_t\ key,
\ \ \ \ enum\ fi_datatype\ datatype,\ enum\ fi_op\ op,\ void\ *context);

ssize_t\ fi_fetch_atomicv(struct\ fid_ep\ *ep,\ const\ struct\ fi_ioc\ *iov,
\ \ \ \ void\ **desc,\ size_t\ count,\ struct\ fi_ioc\ *resultv,
\ \ \ \ void\ **result_desc,\ size_t\ result_count,\ fi_addr_t\ dest_addr,
\ \ \ \ uint64_t\ addr,\ uint64_t\ key,\ enum\ fi_datatype\ datatype,
\ \ \ \ enum\ fi_op\ op,\ void\ *context);

ssize_t\ fi_fetch_atomicmsg(struct\ fid_ep\ *ep,
\ \ \ \ const\ struct\ fi_msg_atomic\ *msg,\ struct\ fi_ioc\ *resultv,
\ \ \ \ void\ **result_desc,\ size_t\ result_count,\ uint64_t\ flags);

ssize_t\ fi_compare_atomic(struct\ fid_ep\ *ep,\ const\ void\ *buf,
\ \ \ \ size_t\ count,\ void\ *desc,\ const\ void\ *compare,
\ \ \ \ void\ *compare_desc,\ void\ *result,\ void\ *result_desc,
\ \ \ \ fi_addr_t\ dest_addr,\ uint64_t\ addr,\ uint64_t\ key,
\ \ \ \ enum\ fi_datatype\ datatype,\ enum\ fi_op\ op,\ void\ *context);

size_t\ fi_compare_atomicv(struct\ fid_ep\ *ep,\ const\ struct\ fi_ioc\ *iov,
\ \ \ \ \ \ \ void\ **desc,\ size_t\ count,\ const\ struct\ fi_ioc\ *comparev,
\ \ \ \ \ \ \ void\ **compare_desc,\ size_t\ compare_count,\ struct\ fi_ioc\ *resultv,
\ \ \ \ \ \ \ void\ **result_desc,\ size_t\ result_count,\ fi_addr_t\ dest_addr,
\ \ \ \ \ \ \ uint64_t\ addr,\ uint64_t\ key,\ enum\ fi_datatype\ datatype,
\ \ \ \ \ \ \ enum\ fi_op\ op,\ void\ *context);

ssize_t\ fi_compare_atomicmsg(struct\ fid_ep\ *ep,
\ \ \ \ const\ struct\ fi_msg_atomic\ *msg,\ const\ struct\ fi_ioc\ *comparev,
\ \ \ \ void\ **compare_desc,\ size_t\ compare_count,
\ \ \ \ struct\ fi_ioc\ *resultv,\ void\ **result_desc,\ size_t\ result_count,
\ \ \ \ uint64_t\ flags);

int\ fi_atomicvalid(struct\ fid_ep\ *ep,\ enum\ fi_datatype\ datatype,
\ \ \ \ enum\ fi_op\ op,\ size_t\ *count);

int\ fi_fetch_atomicvalid(struct\ fid_ep\ *ep,\ enum\ fi_datatype\ datatype,
\ \ \ \ enum\ fi_op\ op,\ size_t\ *count);

int\ fi_compare_atomicvalid(struct\ fid_ep\ *ep,\ enum\ fi_datatype\ datatype,
\ \ \ \ enum\ fi_op\ op,\ size_t\ *count);

int\ fi_query_atomic(struct\ fid_domain\ *domain,
\ \ \ \ enum\ fi_datatype\ datatype,\ enum\ fi_op\ op,
\ \ \ \ struct\ fi_atomic_attr\ *attr,\ uint64_t\ flags);
\f[]
.fi
.SH ARGUMENTS
.PP
\f[I]ep\f[] : Fabric endpoint on which to initiate atomic operation.
.PP
\f[I]buf\f[] : Local data buffer that specifies first operand of atomic
operation
.PP
\f[I]iov / comparev / resultv\f[] : Vectored data buffer(s).
.PP
\f[I]count / compare_count / result_count\f[] : Count of vectored data
entries.
The number of elements referenced, where each element is the indicated
datatype.
.PP
\f[I]addr\f[] : Address of remote memory to access.
.PP
\f[I]key\f[] : Protection key associated with the remote memory.
.PP
\f[I]datatype\f[] : Datatype associated with atomic operands
.PP
\f[I]op\f[] : Atomic operation to perform
.PP
\f[I]compare\f[] : Local compare buffer, containing comparison data.
.PP
\f[I]result\f[] : Local data buffer to store initial value of remote
buffer
.PP
\f[I]desc / compare_desc / result_desc\f[] : Data descriptor associated
with the local data buffer, local compare buffer, and local result
buffer, respectively.
.PP
\f[I]dest_addr\f[] : Destination address for connectionless atomic
operations.
Ignored for connected endpoints.
.PP
\f[I]msg\f[] : Message descriptor for atomic operations
.PP
\f[I]flags\f[] : Additional flags to apply for the atomic operation
.PP
\f[I]context\f[] : User specified pointer to associate with the
operation.
.SH DESCRIPTION
.PP
Atomic transfers are used to read and update data located in remote
memory regions in an atomic fashion.
Conceptually, they are similar to local atomic operations of a similar
nature (e.g.
atomic increment, compare and swap, etc.).
Updates to remote data involve one of several operations on the data,
and act on specific types of data, as listed below.
As such, atomic transfers have knowledge of the format of the data being
accessed.
A single atomic function may operate across an array of data applying an
atomic operation to each entry, but the atomicity of an operation is
limited to a single datatype or entry.
.SS Atomic Data Types
.PP
Atomic functions may operate on one of the following identified data
types.
A given atomic function may support any datatype, subject to provider
implementation constraints.
.PP
\f[I]FI_INT8\f[] : Signed 8\-bit integer.
.PP
\f[I]FI_UINT8\f[] : Unsigned 8\-bit integer.
.PP
\f[I]FI_INT16\f[] : Signed 16\-bit integer.
.PP
\f[I]FI_UINT16\f[] : Unsigned 16\-bit integer.
.PP
\f[I]FI_INT32\f[] : Signed 32\-bit integer.
.PP
\f[I]FI_UINT32\f[] : Unsigned 32\-bit integer.
.PP
\f[I]FI_INT64\f[] : Signed 64\-bit integer.
.PP
\f[I]FI_UINT64\f[] : Unsigned 64\-bit integer.
.PP
\f[I]FI_FLOAT\f[] : A single\-precision floating point value (IEEE 754).
.PP
\f[I]FI_DOUBLE\f[] : A double\-precision floating point value (IEEE
754).
.PP
\f[I]FI_FLOAT_COMPLEX\f[] : An ordered pair of single\-precision
floating point values (IEEE 754), with the first value representing the
real portion of a complex number and the second representing the
imaginary portion.
.PP
\f[I]FI_DOUBLE_COMPLEX\f[] : An ordered pair of double\-precision
floating point values (IEEE 754), with the first value representing the
real portion of a complex number and the second representing the
imaginary portion.
.PP
\f[I]FI_LONG_DOUBLE\f[] : A double\-extended precision floating point
value (IEEE 754).
Note that the size of a long double and number of bits used for
precision is compiler, platform, and/or provider specific.
Developers that use long double should ensure that libfabric is built
using a long double format that is compatible with their application,
and that format is supported by the provider.
The mechanism used for this validation is currently beyond the scope of
the libfabric API.
.PP
\f[I]FI_LONG_DOUBLE_COMPLEX\f[] : An ordered pair of double\-extended
precision floating point values (IEEE 754), with the first value
representing the real portion of a complex number and the second
representing the imaginary portion.
.SS Atomic Operations
.PP
The following atomic operations are defined.
An atomic operation often acts against a target value in the remote
memory buffer and source value provided with the atomic function.
It may also carry source data to replace the target value in compare and
swap operations.
A conceptual description of each operation is provided.
.PP
\f[I]FI_MIN\f[] : Minimum
.IP
.nf
\f[C]
if\ (buf[i]\ <\ addr[i])
\ \ \ \ addr[i]\ =\ buf[i]
\f[]
.fi
.PP
\f[I]FI_MAX\f[] : Maximum
.IP
.nf
\f[C]
if\ (buf[i]\ >\ addr[i])
\ \ \ \ addr[i]\ =\ buf[i]
\f[]
.fi
.PP
\f[I]FI_SUM\f[] : Sum
.IP
.nf
\f[C]
addr[i]\ =\ addr[i]\ +\ buf[i]
\f[]
.fi
.PP
\f[I]FI_PROD\f[] : Product
.IP
.nf
\f[C]
addr[i]\ =\ addr[i]\ *\ buf[i]
\f[]
.fi
.PP
\f[I]FI_LOR\f[] : Logical OR
.IP
.nf
\f[C]
addr[i]\ =\ (addr[i]\ ||\ buf[i])
\f[]
.fi
.PP
\f[I]FI_LAND\f[] : Logical AND
.IP
.nf
\f[C]
addr[i]\ =\ (addr[i]\ &&\ buf[i])
\f[]
.fi
.PP
\f[I]FI_BOR\f[] : Bitwise OR
.IP
.nf
\f[C]
addr[i]\ =\ addr[i]\ |\ buf[i]
\f[]
.fi
.PP
\f[I]FI_BAND\f[] : Bitwise AND
.IP
.nf
\f[C]
addr[i]\ =\ addr[i]\ &\ buf[i]
\f[]
.fi
.PP
\f[I]FI_LXOR\f[] : Logical exclusive\-OR (XOR)
.IP
.nf
\f[C]
addr[i]\ =\ ((addr[i]\ &&\ !buf[i])\ ||\ (!addr[i]\ &&\ buf[i]))
\f[]
.fi
.PP
\f[I]FI_BXOR\f[] : Bitwise exclusive\-OR (XOR)
.IP
.nf
\f[C]
addr[i]\ =\ addr[i]\ ^\ buf[i]
\f[]
.fi
.PP
\f[I]FI_ATOMIC_READ\f[] : Read data atomically
.IP
.nf
\f[C]
result[i]\ =\ addr[i]
\f[]
.fi
.PP
\f[I]FI_ATOMIC_WRITE\f[] : Write data atomically
.IP
.nf
\f[C]
addr[i]\ =\ buf[i]
\f[]
.fi
.PP
\f[I]FI_CSWAP\f[] : Compare values and if equal swap with data
.IP
.nf
\f[C]
if\ (compare[i]\ ==\ addr[i])
\ \ \ \ addr[i]\ =\ buf[i]
\f[]
.fi
.PP
\f[I]FI_CSWAP_NE\f[] : Compare values and if not equal swap with data
.IP
.nf
\f[C]
if\ (compare[i]\ !=\ addr[i])
\ \ \ \ addr[i]\ =\ buf[i]
\f[]
.fi
.PP
\f[I]FI_CSWAP_LE\f[] : Compare values and if less than or equal swap
with data
.IP
.nf
\f[C]
if\ (compare[i]\ <=\ addr[i])
\ \ \ \ addr[i]\ =\ buf[i]
\f[]
.fi
.PP
\f[I]FI_CSWAP_LT\f[] : Compare values and if less than swap with data
.IP
.nf
\f[C]
if\ (compare[i]\ <\ addr[i])
\ \ \ \ addr[i]\ =\ buf[i]
\f[]
.fi
.PP
\f[I]FI_CSWAP_GE\f[] : Compare values and if greater than or equal swap
with data
.IP
.nf
\f[C]
if\ (compare[i]\ >=\ addr[i])
\ \ \ \ addr[i]\ =\ buf[i]
\f[]
.fi
.PP
\f[I]FI_CSWAP_GT\f[] : Compare values and if greater than swap with data
.IP
.nf
\f[C]
if\ (compare[i]\ >\ addr[i])
\ \ \ \ addr[i]\ =\ buf[i]
\f[]
.fi
.PP
\f[I]FI_MSWAP\f[] : Swap masked bits with data
.IP
.nf
\f[C]
addr[i]\ =\ (buf[i]\ &\ compare[i])\ |\ (addr[i]\ &\ ~compare[i])
\f[]
.fi
.SS Base Atomic Functions
.PP
The base atomic functions \-\- fi_atomic, fi_atomicv, fi_atomicmsg \-\-
are used to transmit data to a remote node, where the specified atomic
operation is performed against the target data.
The result of a base atomic function is stored at the remote memory
region.
The main difference between atomic functions are the number and type of
parameters that they accept as input.
Otherwise, they perform the same general function.
.PP
The call fi_atomic transfers the data contained in the user\-specified
data buffer to a remote node.
For unconnected endpoints, the destination endpoint is specified through
the dest_addr parameter.
Unless the endpoint has been configured differently, the data buffer
passed into fi_atomic must not be touched by the application until the
fi_atomic call completes asynchronously.
The target buffer of a base atomic operation must allow for remote read
an/or write access, as appropriate.
.PP
The fi_atomicv call adds support for a scatter\-gather list to
fi_atomic.
The fi_atomicv transfers the set of data buffers referenced by the ioc
parameter to the remote node for processing.
.PP
The fi_inject_atomic call is an optimized version of fi_atomic.
The fi_inject_atomic function behaves as if the FI_INJECT transfer flag
were set, and FI_COMPLETION were not.
That is, the data buffer is available for reuse immediately on returning
from from fi_inject_atomic, and no completion event will be generated
for this atomic.
The completion event will be suppressed even if the endpoint has not
been configured with FI_SELECTIVE_COMPLETION.
See the flags discussion below for more details.
The requested message size that can be used with fi_inject_atomic is
limited by inject_size.
.PP
The fi_atomicmsg call supports atomic functions over both connected and
unconnected endpoints, with the ability to control the atomic operation
per call through the use of flags.
The fi_atomicmsg function takes a struct fi_msg_atomic as input.
.IP
.nf
\f[C]
struct\ fi_msg_atomic\ {
\ \ \ \ const\ struct\ fi_ioc\ *msg_iov;\ /*\ local\ scatter\-gather\ array\ */
\ \ \ \ void\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ **desc;\ \ \ /*\ local\ access\ descriptors\ */
\ \ \ \ size_t\ \ \ \ \ \ \ \ \ \ \ \ \ \ iov_count;/*\ #\ elements\ in\ ioc\ */
\ \ \ \ const\ void\ \ \ \ \ \ \ \ \ \ *addr;\ \ \ \ /*\ optional\ endpoint\ address\ */
\ \ \ \ const\ struct\ fi_rma_ioc\ *rma_iov;\ /*\ remote\ SGL\ */
\ \ \ \ size_t\ \ \ \ \ \ \ \ \ \ \ \ \ \ rma_iov_count;/*\ #\ elements\ in\ remote\ SGL\ */
\ \ \ \ enum\ fi_datatype\ \ \ \ datatype;\ /*\ operand\ datatype\ */
\ \ \ \ enum\ fi_op\ \ \ \ \ \ \ \ \ \ op;\ \ \ \ \ \ \ /*\ atomic\ operation\ */
\ \ \ \ void\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ *context;\ /*\ user\-defined\ context\ */
\ \ \ \ uint64_t\ \ \ \ \ \ \ \ \ \ \ \ data;\ \ \ \ \ /*\ optional\ data\ */
};

struct\ fi_rma_ioc\ {
\ \ \ \ uint64_t\ \ \ \ \ \ \ \ \ \ \ addr;\ \ \ \ \ \ /*\ target\ address\ */
\ \ \ \ size_t\ \ \ \ \ \ \ \ \ \ \ \ \ count;\ \ \ \ \ /*\ #\ target\ operands\ */
\ \ \ \ uint64_t\ \ \ \ \ \ \ \ \ \ \ key;\ \ \ \ \ \ \ /*\ access\ key\ */
};
\f[]
.fi
.PP
The following list of atomic operations are usable with base atomic
operations: FI_MIN, FI_MAX, FI_SUM, FI_PROD, FI_LOR, FI_LAND, FI_BOR,
FI_BAND, FI_LXOR, FI_BXOR, and FI_ATOMIC_WRITE.
.SS Fetch\-Atomic Functions
.PP
The fetch atomic functions \-\- fi_fetch_atomic, fi_fetch_atomicv, and
fi_fetch atomicmsg \-\- behave similar to the equivalent base atomic
function.
The difference between the fetch and base atomic calls are the fetch
atomic routines return the initial value that was stored at the target
to the user.
The initial value is read into the user provided result buffer.
The target buffer of fetch\-atomic operations must be enabled for remote
read access.
.PP
The following list of atomic operations are usable with fetch atomic
operations: FI_MIN, FI_MAX, FI_SUM, FI_PROD, FI_LOR, FI_LAND, FI_BOR,
FI_BAND, FI_LXOR, FI_BXOR, FI_ATOMIC_READ, and FI_ATOMIC_WRITE.
.PP
For FI_ATOMIC_READ operations, the source buffer operand (e.g.
fi_fetch_atomic buf parameter) is ignored and may be NULL.
The results are written into the result buffer.
.SS Compare\-Atomic Functions
.PP
The compare atomic functions \-\- fi_compare_atomic, fi_compare_atomicv,
and fi_compare atomicmsg \-\- are used for operations that require
comparing the target data against a value before performing a swap
operation.
The compare atomic functions support: FI_CSWAP, FI_CSWAP_NE,
FI_CSWAP_LE, FI_CSWAP_LT, FI_CSWAP_GE, FI_CSWAP_GT, and FI_MSWAP.
.SS Atomic Valid Functions
.PP
The atomic valid functions \-\- fi_atomicvalid, fi_fetch_atomicvalid,
and fi_compare_atomicvalid \-\-indicate which operations the local
provider supports.
Needed operations not supported by the provider must be emulated by the
application.
Each valid call corresponds to a set of atomic functions.
fi_atomicvalid checks whether a provider supports a specific base atomic
operation for a given datatype and operation.
fi_fetch_atomicvalid indicates if a provider supports a specific
fetch\-atomic operation for a given datatype and operation.
And fi_compare_atomicvalid checks if a provider supports a specified
compare\-atomic operation for a given datatype and operation.
.PP
If an operation is supported, an atomic valid call will return 0, along
with a count of atomic data units that a single function call will
operate on.
.SS Query Atomic Attributes
.PP
The fi_query_atomic call acts as an enhanced atomic valid operation (see
the atomic valid function definitions above).
It is provided, in part, for future extensibility.
The query operation reports which atomic operations are supported by the
domain, for suitably configured endpoints.
.PP
The behavior of fi_query_atomic is adjusted based on the flags
parameter.
If flags is 0, then the operation reports the supported atomic
attributes for base atomic operations, similar to fi_atomicvalid for
endpoints.
If flags has the FI_FETCH_ATOMIC bit set, the operation behaves similar
to fi_fetch_atomicvalid.
Similarly, the flag bit FI_COMPARE_ATOMIC results in query acting as
fi_compare_atomicvalid.
The FI_FETCH_ATOMIC and FI_COMPARE_ATOMIC bits may not both be set.
.PP
If the FI_TAGGED bit is set, the provider will indicate if it supports
atomic operations to tagged receive buffers.
The FI_TAGGED bit may be used by itself, or in conjunction with the
FI_FETCH_ATOMIC and FI_COMPARE_ATOMIC flags.
.PP
The output of fi_query_atomic is struct fi_atomic_attr:
.IP
.nf
\f[C]
struct\ fi_atomic_attr\ {
\ \ \ \ size_t\ count;
\ \ \ \ size_t\ size;
};
\f[]
.fi
.PP
The count attribute field is as defined for the atomic valid calls.
The size field indicates the size in bytes of the atomic datatype.
.SS Completions
.PP
Completed atomic operations are reported to the user through one or more
event collectors associated with the endpoint.
Users provide context which are associated with each operation, and is
returned to the user as part of the event completion.
See fi_cq for completion event details.
.PP
Updates to the target buffer of an atomic operation are visible to
processes running on the target system either after a completion has
been generated, or after the completion of an operation initiated after
the atomic call with a fencing operation occurring in between.
For example, the target process may be notified by the initiator sending
a message after the atomic call completes, or sending a fenced message
immediately after initiating the atomic operation.
.SH FLAGS
.PP
The fi_atomicmsg, fi_fetch_atomicmsg, and fi_compare_atomicmsg calls
allow the user to specify flags which can change the default data
transfer operation.
Flags specified with atomic message operations override most flags
previously configured with the endpoint, except where noted (see
fi_control).
The following list of flags are usable with atomic message calls.
.PP
\f[I]FI_COMPLETION\f[] : Indicates that a completion entry should be
generated for the specified operation.
The endpoint must be bound to a completion queue with
FI_SELECTIVE_COMPLETION that corresponds to the specified operation, or
this flag is ignored.
.PP
\f[I]FI_MORE\f[] : Indicates that the user has additional requests that
will immediately be posted after the current call returns.
Use of this flag may improve performance by enabling the provider to
optimize its access to the fabric hardware.
.PP
\f[I]FI_INJECT\f[] : Indicates that the outbound non\-const data buffers
(buf and compare parameters) should be returned to user immediately
after the call returns, even if the operation is handled asynchronously.
This may require that the underlying provider implementation copy the
data into a local buffer and transfer out of that buffer.
The use of output result buffers are not affected by this flag.
This flag can only be used with messages smaller than inject_size.
.PP
\f[I]FI_FENCE\f[] : Indicates that the requested operation, also known
as the fenced operation, be deferred until all previous operations
targeting the same target endpoint have completed.
.PP
\f[I]FI_TAGGED\f[] : Specifies that the target of the atomic operation
is a tagged receive buffer instead of an RMA buffer.
When a tagged buffer is the target memory region, the addr parameter is
used as a 0\-based byte offset into the tagged buffer, with the key
parameter specifying the tag.
.SH RETURN VALUE
.PP
Returns 0 on success.
On error, a negative value corresponding to fabric errno is returned.
Fabric errno values are defined in \f[C]rdma/fi_errno.h\f[].
.SH ERRORS
.PP
\f[I]\-FI_EAGAIN\f[] : See \f[C]fi_msg\f[](3) for a detailed description
of handling FI_EAGAIN.
.PP
\f[I]\-FI_EOPNOTSUPP\f[] : The requested atomic operation is not
supported on this endpoint.
.PP
\f[I]\-FI_EMSGSIZE\f[] : The number of atomic operations in a single
request exceeds that supported by the underlying provider.
.SH NOTES
.PP
Atomic operations operate on an array of values of a specific data type.
Atomicity is only guaranteed for each data type operation, not across
the entire array.
The following pseudo\-code demonstrates this operation for 64\-bit
unsigned atomic write.
ATOMIC_WRITE_U64 is a platform dependent macro that atomically writes 8
bytes to an aligned memory location.
.IP
.nf
\f[C]
fi_atomic(ep,\ buf,\ count,\ NULL,\ dest_addr,\ addr,\ key,
\ \ \ \ \ \ FI_UINT64,\ FI_ATOMIC_WRITE,\ context)
{
\ \ \ \ for\ (i\ =\ 1;\ i\ <\ count;\ i\ ++)
\ \ \ \ \ \ \ \ ATOMIC_WRITE_U64(((uint64_t\ *)\ addr)[i],
\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ ((uint64_t\ *)\ buf)[i]);
}
\f[]
.fi
.PP
The number of array elements to operate on is specified through a count
parameter.
This must be between 1 and the maximum returned through the relevant
valid operation, inclusive.
The requested operation and data type must also be valid for the given
provider.
.SH SEE ALSO
.PP
\f[C]fi_getinfo\f[](3), \f[C]fi_endpoint\f[](3), \f[C]fi_domain\f[](3),
\f[C]fi_cq\f[](3), \f[C]fi_rma\f[](3)
.SH AUTHORS
OpenFabrics.