axpy_batch

oneMKL - Data Parallel C++ Developer Reference

Download PDF

ID 772045

Date 6/24/2024

Version

Public

A newer version of this document is available. Customers should click here to go to the newest version.

Visible to Intel only — GUID: GUID-A4B57513-DA8B-4DDB-B48A-C8EDA6765B8B

View Details

axpy_batch

Computes a group of axpy operations.

Description

The axpy_batch routines are batched versions of axpy, performing multiple axpy operations in a single call. Each axpy operation adds a scalar-vector product to a vector.

axpy_batch supports the following precisions:

T
`float`
`double`
`std::complex<float>`
`std::complex<double>`

axpy_batch (Buffer Version)

Buffer version of axpy_batch supports only strided API.

Strided API

Strided API operation is defined as:

for i = 0 … batch_size – 1
    X and Y are vectors at offset i * stridex and i * stridey in x and y
    Y = alpha * X + Y
end for

where:

alpha is scalar
X and Y are vectors

For strided API, all vectors X and Y have same parameters (size, increments) and are stored at constant stride given by stridex and stridey from each other. The x and y arrays contain all the input vectors. Total number of vectors in x and y are given by batch_size parameter.

Syntax

namespace oneapi::mkl::blas::column_major {
    void axpy_batch(sycl::queue &queue,
                    std::int64_t n,
                    T alpha,
                    sycl::buffer<T, 1> &x,
                    std::int64_t incx,
                    std::int64_t stridex,
                    sycl::buffer<T, 1> &y,
                    std::int64_t incy,
                    std::int64_t stridey,
                    std::int64_t batch_size)
}

namespace oneapi::mkl::blas::row_major {
    void axpy_batch(sycl::queue &queue,
                    std::int64_t n,
                    T alpha,
                    sycl::buffer<T, 1> &x,
                    std::int64_t incx,
                    std::int64_t stridex,
                    sycl::buffer<T, 1> &y,
                    std::int64_t incy,
                    std::int64_t stridey,
                    std::int64_t batch_size)
}

Input Parameters

queue: The queue where the routine should be executed.
n: Number of elements in vectors X and Y.
alpha: Specifies the scalar alpha.
x: Buffer holding input vectors X. Size of the buffer must be at least batch_size * stridex.
incx: Stride between two consecutive elements of X vectors. Must not be zero.
stridex: Stride between two consecutive X vectors. Must be at least zero.
y: Buffer holding input/output vectors Y. Size of the buffer must be at least batch_size * stridey.
incy: Stride between two consecutive elements of Y vectors. Must not be zero.
stridey: Stride between two consecutive Y vectors. Must be at least (1 + (n-1)*abs(incy)). See Matrix Storage for more details.
batch_size: Number of axpy computations to perform. Must be at least zero.

Output Parameters

y: Output buffer overwritten by batch_sizeaxpy operations of the form alpha * X + Y.

axpy_batch (USM Version)

USM version of axpy_batch supports group API and strided API.

Group API

The type Ti of integer pointers in the group API may be either std::int64_t or std::int32_t.

Group API operation is defined as:

idx = 0
for i = 0 … group_count – 1
     for j = 0 … group_size – 1
         X and Y are vectors at x[idx] and y[idx]
         Y = alpha[i] * X + Y
         idx = idx + 1
     end for
end for

where:

alpha is scalar
X and Y are vectors

For group API, each group contains vectors with the same parameters (size and increment). The x and y arrays contain the pointers for all the input vectors. Total number of vectors in x and y are given by:

Syntax

namespace oneapi::mkl::blas::column_major {
    sycl::event axpy_batch(sycl::queue &queue,
                           const Ti *n,
                           const T *alpha,
                           const T **x,
                           const Ti *incx,
                           T **y,
                           const Ti *incy,
                           std::int64_t group_count,
                           const Ti *group_size,
                           const std::vector<sycl::event> &dependencies = {})
}

namespace oneapi::mkl::blas::row_major {
    sycl::event axpy_batch(sycl::queue &queue,
                           const Ti *n,
                           const T *alpha,
                           const T **x,
                           const Ti *incx,
                           T **y,
                           const Ti *incy,
                           std::int64_t group_count,
                           const Ti *group_size,
                           const std::vector<sycl::event> &dependencies = {})
}

Input Parameters

queue: The queue where the routine should be executed.
n: Array of group_count integers. n[i] specifies number of elements in vectors X and Y for every vector in group i.
alpha: Array of group_count scalar elements. alpha[i] specifies scaling factor for vector X in group i.
x: Array of pointers to input vectors X with size total_batch_count. Size of the array allocated for the X vector of the group i must be at least (1 + (n[i] – 1)*abs(incx[i])). See Matrix Storage for more details.
incx: Array of group_count integers. incx[i] specifies stride of vector X in group i. Must not be zero.
y: Array of pointers to input/output vectors Y with size total_batch_count. Size of the array allocated for the Y vector of the group i must be at least (1 + (n[i] – 1)*abs(incy[i])). See Matrix Storage for more details.
incy: Array of group_count integers. incy[i] specifies the stride of vector Y in group i. Must not be zero.
group_count: Number of groups. Must be at least zero.
group_size: Array of group_count integers. group_size[i] specifies the number of axpy operations in group i. Each element in group_size must be at least zero.
dependencies: List of events to wait for before starting computation, if any. If omitted, defaults to no dependencies.

Output Parameters

y: Array of pointers holding Y vectors, overwritten by total_batch_countaxpy operations of the form alpha * X + Y.

Return Values

Output event to wait on to ensure computation is complete.

Strided API

Strided API operation is defined as:

for i = 0 … batch_size – 1
    X and Y are vectors at offset i * stridex and i * stridey in x and y
    Y = alpha * X + Y
end for

where:

alpha is scalar
X and Y are vectors

Syntax

namespace oneapi::mkl::blas::column_major {
    sycl::event axpy_batch(sycl::queue &queue,
                           std::int64_t n,
                           oneapi::mkl::value_or_pointer<T> alpha,
                           const T *x,
                           std::int64_t incx,
                           std::int64_t stridex,
                           T *y,
                           std::int64_t incy,
                           std::int64_t stridey,
                           std::int64_t batch_size,
                           const std::vector<sycl::event> &dependencies = {})
}

namespace oneapi::mkl::blas::row_major {
    sycl::event axpy_batch(sycl::queue &queue,
                           std::int64_t n,
                           oneapi::mkl::value_or_pointer<T> alpha,
                           const T *x,
                           std::int64_t incx,
                           std::int64_t stridex,
                           T *y,
                           std::int64_t incy,
                           std::int64_t stridey,
                           std::int64_t batch_size,
                           const std::vector<sycl::event> &dependencies = {})
}

Input Parameters

queue: The queue where the routine should be executed.
n: Number of elements in vectors X and Y.
alpha: Specifies the scalar alpha. See Scalar Arguments for more information on the value_or_pointer data type.
x: Pointer to input vectors X. Size of the array must be at least batch_size * stridex.
incx: Stride between two consecutive elements of X vectors. Must not be zero.
stridex: Stride between two consecutive X vectors. Must be at least zero.
y: Pointer to input/output vectors Y. Size of the array must be at least batch_size * stridey.
incy: Stride between two consecutive elements of Y vectors. Must not be zero.
stridey: Stride between two consecutive Y vectors. Must be at least (1 + (n-1)*abs(incy)). See Matrix Storage for more details.
batch_size: Number of axpy computations to perform. Must be at least zero.
dependencies: List of events to wait for before starting computation, if any. If omitted, defaults to no dependencies.

Output Parameters

y: Pointer to output vectors Y overwritten by batch_sizeaxpy operations of the form alpha * X + Y.

Return Values

Output event to wait on to ensure computation is complete.

Select Your Language

Using Intel.com Search

Quick Links

Recent Searches

Advanced Search

Only search in

oneMKL - Data Parallel C++ Developer Reference

axpy_batch

Description

axpy_batch (Buffer Version)

axpy_batch (USM Version)