[packages/libfabric] - initial

Sat Feb 21 09:41:06 CET 2015

commit 1db96c92569b62915ae5e0ac9c4479f6e8064e10
Author: Jakub Bogusz <qboosh at pld-linux.org>
Date:   Sat Feb 21 09:43:52 2015 +0100

    - initial

 libfabric-missing.patch | 539 ++++++++++++++++++++++++++++++++++++++++++++++++
 libfabric.spec          | 106 ++++++++++
 2 files changed, 645 insertions(+)
---

diff --git a/libfabric.spec b/libfabric.spec
new file mode 100644
index 0000000..a5a723c
--- /dev/null
+++ b/libfabric.spec
@@ -0,0 +1,106 @@
+#
+# Conditional build:
+%bcond_with	psm	# infinipath-psm provider
+#
+%ifnarch %{ix86} %{x8664}
+%undefine	with_psm
+%endif
+Summary:	User-space RDMA Fabric interface library
+Summary(pl.UTF-8):	Biblioteka interfejsu przestrzeni użytkownika RDMA Fabric
+Name:		libfabric
+%define	subver	rc1
+Version:	1.0.0
+Release:	1
+License:	BSD or GPL v2
+Group:		Libraries
+Source0:	https://www.openfabrics.org/downloads/ofi/%{name}-%{version}-%{subver}.tar.bz2
+# Source0-md5:	aea309fefa9a3ef40f935a647bfa1691
+Patch0:		%{name}-missing.patch
+URL:		https://github.com/ofiwg/libfabric
+BuildRequires:	autoconf >= 2.57
+BuildRequires:	automake >= 1:1.11
+%{?with_psm:BuildRequires:	infinipath-psm-devel >= 3.1}
+BuildRequires:	libibverbs-devel
+BuildRequires:	libnl-devel >= 3.2
+BuildRequires:	librdmacm-devel
+BuildRequires:	libtool >= 2:2
+BuildRoot:	%{tmpdir}/%{name}-%{version}-root-%(id -u -n)
+
+%description
+libfabric provides a user-space API to access high-performance fabric
+services, such as RDMA.
+
+%description -l pl.UTF-8
+libfabric dostarcza API przestrzeni użytkownika pozwalające na dostęp
+do wysoko wydajnych usług sieci typu fabric, takich jak RDMA.
+
+%package devel
+Summary:	Development files for libfabric library
+Summary(pl.UTF-8):	Pliki programistyczne biblioteki libfabric
+Group:		Development/Libraries
+Requires:	%{name} = %{version}-%{release}
+
+%description devel
+Header files for libfabric library.
+
+%description devel -l pl.UTF-8
+Pliki nagłówkowe biblioteki libfabric.
+
+%package static
+Summary:	Static libfabric library
+Summary(pl.UTF-8):	Statyczna biblioteka libfabric
+Group:		Development/Libraries
+Requires:	%{name}-devel = %{version}-%{release}
+
+%description static
+Static libfabric library.
+
+%description static -l pl.UTF-8
+Statyczna biblioteka libfabric.
+
+%prep
+%setup -q -n %{name}-%{version}-%{subver}
+%patch0 -p1
+
+%build
+%{__libtoolize}
+%{__aclocal} -I config
+%{__autoconf}
+%{__autoheader}
+%{__automake}
+%configure \
+	%{!?with_psm:--disable-psm} \
+	--disable-silent-rules
+%{__make}
+
+%install
+rm -rf $RPM_BUILD_ROOT
+
+%{__make} install \
+	DESTDIR=$RPM_BUILD_ROOT
+
+%clean
+rm -rf $RPM_BUILD_ROOT
+
+%post	-p /sbin/ldconfig
+%postun	-p /sbin/ldconfig
+
+%files
+%defattr(644,root,root,755)
+%doc AUTHORS COPYING README
+%attr(755,root,root) %{_libdir}/libfabric.so.*.*.*
+%attr(755,root,root) %ghost %{_libdir}/libfabric.so.1
+
+%files devel
+%defattr(644,root,root,755)
+%attr(755,root,root) %{_libdir}/libfabric.so
+%{_libdir}/libfabric.la
+%{_includedir}/rdma/fabric.h
+%{_includedir}/rdma/fi_*.h
+%{_mandir}/man3/fi_*.3*
+%{_mandir}/man7/fabric.7*
+%{_mandir}/man7/fi_direct.7*
+
+%files static
+%defattr(644,root,root,755)
+%{_libdir}/libfabric.a
diff --git a/libfabric-missing.patch b/libfabric-missing.patch
new file mode 100644
index 0000000..836409c
--- /dev/null
+++ b/libfabric-missing.patch
@@ -0,0 +1,539 @@
+--- libfabric-1.0.0-rc1/man/fi_atomic.3.orig	1970-01-01 01:00:00.000000000 +0100
++++ libfabric-1.0.0-rc1/man/fi_atomic.3	2015-02-21 08:02:51.548615727 +0100
+@@ -0,0 +1,526 @@
++.TH fi_atomic 3 "2015\-01\-28" "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_atomic_valid / fi_fetch_atomic_valid / fi_compare_atomic_valid :
++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);
++\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.
++.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).
++.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 AN
++.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]
++buf[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\ (addr[i]\ ==\ compare[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\ (addr[i]\ !=\ compare[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\ (addr[i]\ <=\ compare[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\ (addr[i]\ <\ compare[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\ (addr[i]\ >=\ compare[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\ (addr[i]\ >\ compare[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_COMPLETION.
++See the flags discussion below for more details.
++.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
++.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 both the base
++atomic and 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.
++.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 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_eq 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 an event queue with FI_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_REMOTE_SIGNAL\f[] : Indicates that a completion event at the
++target process should be generated for the given operation.
++The remote endpoint must be configured with FI_REMOTE_SIGNAL, or this
++flag will be ignored by the target.
++.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.
++.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.
++.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_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
++.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_eq\f[](3), \f[C]fi_rma\f[](3)
++.SH AUTHORS
++OpenFabrics.
+--- libfabric-1.0.0-rc1/Makefile.am.orig	2015-02-02 06:11:53.000000000 +0100
++++ libfabric-1.0.0-rc1/Makefile.am	2015-02-21 08:59:52.938472096 +0100
+@@ -280,6 +280,7 @@
+ 
+ real_man_pages = \
+         man/fabric.7 \
++        man/fi_atomic.3 \
+         man/fi_av.3 \
+         man/fi_cm.3 \
+         man/fi_cntr.3 \
================================================================

---- gitweb:

http://git.pld-linux.org/gitweb.cgi/packages/libfabric.git/commitdiff/1db96c92569b62915ae5e0ac9c4479f6e8064e10

