Operators

Applies to Linux

2023-06-14

20 min read time

operation

struct operation

The operation interface represents an action an instruction will perform. All operation classes must be CopyConstructible.

bool migraphx::internal::is_context_free(const operation &x)

Returns true if operation does not require a context to run compute.

bool migraphx::internal::has_finalize(const operation &x)

Returns true if the operation has a finalize method.

operators

namespace op

Enums

enum padding_mode_t

Values:

enumerator default_

enumerator same

enumerator valid

enumerator same_lower

enumerator same_upper

enum class pooling_mode

Values:

enumerator average

enumerator max

enumerator lpnorm

enum class rnn_direction

Values:

enumerator forward

enumerator reverse

enumerator bidirectional

enum class normalize_attribute

Values:

enumerator use_len

enumerator use_output

enumerator clip_max

enumerator clip_min

enumerator include_max

enumerator include_min

enumerator normalize_padding

Functions

std::ostream &operator<<(std::ostream &os, pooling_mode v)

std::ostream &operator<<(std::ostream &os, rnn_direction v)

struct abs : public migraphx::internal::op::unary<abs>

#include <migraphx/op/abs.hpp>

struct acos : public migraphx::internal::op::unary<acos>

#include <migraphx/op/acos.hpp>

struct acosh : public migraphx::internal::op::unary<acosh>

#include <migraphx/op/acosh.hpp>

struct add : public migraphx::internal::op::binary<add>

#include <migraphx/op/add.hpp>

struct allocate

#include <migraphx/op/allocate.hpp>

struct argmax

#include <migraphx/op/argmax.hpp>

struct argmin

#include <migraphx/op/argmin.hpp>

struct as_shape

#include <migraphx/op/as_shape.hpp>

struct asin : public migraphx::internal::op::unary<asin>

#include <migraphx/op/asin.hpp>

struct asinh : public migraphx::internal::op::unary<asinh>

#include <migraphx/op/asinh.hpp>

struct atan : public migraphx::internal::op::unary<atan>

#include <migraphx/op/atan.hpp>

struct atanh : public migraphx::internal::op::unary<atanh>

#include <migraphx/op/atanh.hpp>

struct batch_norm_inference

#include <migraphx/op/batch_norm_inference.hpp>

template<class Derived>
struct binary : public migraphx::internal::op::op_name<Derived>

#include <migraphx/op/binary.hpp>

struct broadcast

#include <migraphx/op/broadcast.hpp>

The broadcast operator performs the numpy-style broadcasting of an axis of a given tensor. This is achieved primarily by setting the stride of the broadcasted axis to zero. Linear indicies are computed from multi-indicies by computing the inner product on the multi-index with the strides. For example, if we have a tensor A(2,3) it has lengths of (2,3) and strides of (3,1). If we want to compute the linear offset that corresponds to the element on the 2nd row (i = 1) and 3rd column (j = 2), we compute the following inner product (1,2) dot (3, 1) = 1*3 + 2*1 = 5. It is obvious from there that we can negate the effects of a given axis by setting the stride of that axis to zero.

struct capture

#include <migraphx/op/capture.hpp>

struct ceil : public migraphx::internal::op::unary<ceil>

#include <migraphx/op/ceil.hpp>

struct clip

#include <migraphx/op/clip.hpp>

struct concat

#include <migraphx/op/concat.hpp>

struct contiguous

#include <migraphx/op/contiguous.hpp>

The contiguous operator takes a non-standard input tensor and returns the same tensor but in standard form. For example, if input tensor A which has lens = (4,5) is first transposed, i.e. lens = (5,4), this tensor’s data layout remained the same during the transpose operation; only it’s shape lengths and strides were changed. This leaves the tensor in a non-standard form. The contiguous operator copies the underlying data such that resulting tensor is returned to a standard form.

struct convert : public migraphx::internal::op::unary<convert>

#include <migraphx/op/convert.hpp>

struct convolution

#include <migraphx/op/convolution.hpp>

struct cos : public migraphx::internal::op::unary<cos>

#include <migraphx/op/cos.hpp>

struct cosh : public migraphx::internal::op::unary<cosh>

#include <migraphx/op/cosh.hpp>

struct deconvolution

#include <migraphx/op/deconvolution.hpp>

struct dequantizelinear

#include <migraphx/op/dequantizelinear.hpp>

struct div : public migraphx::internal::op::binary<div>

#include <migraphx/op/div.hpp>

struct dot

#include <migraphx/op/dot.hpp>

struct elu

#include <migraphx/op/elu.hpp>

struct equal : public migraphx::internal::op::binary<equal>

#include <migraphx/op/equal.hpp>

struct erf : public migraphx::internal::op::unary<erf>

#include <migraphx/op/erf.hpp>

struct exp : public migraphx::internal::op::unary<exp>

#include <migraphx/op/exp.hpp>

struct flatten

#include <migraphx/op/flatten.hpp>

struct floor : public migraphx::internal::op::unary<floor>

#include <migraphx/op/floor.hpp>

struct fmod : public migraphx::internal::op::binary<fmod>

#include <migraphx/op/fmod.hpp>

struct gather

#include <migraphx/op/gather.hpp>

struct gathernd

#include <migraphx/op/gathernd.hpp>

struct get_tuple_elem

#include <migraphx/op/get_tuple_elem.hpp>

struct greater : public migraphx::internal::op::binary<greater>

#include <migraphx/op/greater.hpp>

struct gru

#include <migraphx/op/gru.hpp>

struct highest

#include <migraphx/op/reduce_op.hpp>

struct identity

#include <migraphx/op/identity.hpp>

struct if_op

#include <migraphx/op/if_op.hpp>

struct im2col

#include <migraphx/op/im2col.hpp>

struct isnan : public migraphx::internal::op::unary<isnan>

#include <migraphx/op/isnan.hpp>

struct leaky_relu

#include <migraphx/op/leaky_relu.hpp>

struct less : public migraphx::internal::op::binary<less>

#include <migraphx/op/less.hpp>

struct load

#include <migraphx/op/load.hpp>

struct log : public migraphx::internal::op::unary<log>

#include <migraphx/op/log.hpp>

struct logical_and : public migraphx::internal::op::binary<logical_and>

#include <migraphx/op/logical_and.hpp>

struct logical_or : public migraphx::internal::op::binary<logical_or>

#include <migraphx/op/logical_or.hpp>

struct logical_xor : public migraphx::internal::op::binary<logical_xor>

#include <migraphx/op/logical_xor.hpp>

struct logsoftmax

#include <migraphx/op/logsoftmax.hpp>

struct loop

#include <migraphx/op/loop.hpp>

struct lowest

#include <migraphx/op/reduce_op.hpp>

struct lrn

#include <migraphx/op/lrn.hpp>

struct lstm

#include <migraphx/op/lstm.hpp>

struct max : public migraphx::internal::op::binary<max>

#include <migraphx/op/max.hpp>

struct min : public migraphx::internal::op::binary<min>

#include <migraphx/op/min.hpp>

struct mod : public migraphx::internal::op::binary<mod>

#include <migraphx/op/mod.hpp>

struct mul : public migraphx::internal::op::binary<mul>

#include <migraphx/op/mul.hpp>

struct multibroadcast

#include <migraphx/op/multibroadcast.hpp>

struct multinomial

#include <migraphx/op/multinomial.hpp>

struct neg : public migraphx::internal::op::unary<neg>

#include <migraphx/op/neg.hpp>

struct nonmaxsuppression

#include <migraphx/op/nonmaxsuppression.hpp>

struct nonzero

#include <migraphx/op/nonzero.hpp>

struct one

#include <migraphx/op/reduce_op.hpp>

template<class Derived>
struct op_name

#include <migraphx/op/name.hpp>

Create name from class.

Subclassed by migraphx::internal::op::binary< add >, migraphx::internal::op::binary< div >, migraphx::internal::op::binary< equal >, migraphx::internal::op::binary< fmod >, migraphx::internal::op::binary< greater >, migraphx::internal::op::binary< less >, migraphx::internal::op::binary< logical_and >, migraphx::internal::op::binary< logical_or >, migraphx::internal::op::binary< logical_xor >, migraphx::internal::op::binary< max >, migraphx::internal::op::binary< min >, migraphx::internal::op::binary< mod >, migraphx::internal::op::binary< mul >, migraphx::internal::op::binary< pow >, migraphx::internal::op::binary< prelu >, migraphx::internal::op::binary< sqdiff >, migraphx::internal::op::binary< sub >, migraphx::internal::op::prefix_scan_op< prefix_scan_sum >, migraphx::internal::op::reduce_op< reduce_max >, migraphx::internal::op::reduce_op< reduce_mean >, migraphx::internal::op::reduce_op< reduce_min >, migraphx::internal::op::reduce_op< reduce_prod >, migraphx::internal::op::reduce_op< reduce_sum >, migraphx::internal::op::scatter< scatter_add >, migraphx::internal::op::scatter< scatter_mul >, migraphx::internal::op::scatter< scatter_none >, migraphx::internal::op::scatternd_op< scatternd_add >, migraphx::internal::op::scatternd_op< scatternd_mul >, migraphx::internal::op::scatternd_op< scatternd_none >, migraphx::internal::op::unary< abs >, migraphx::internal::op::unary< acos >, migraphx::internal::op::unary< acosh >, migraphx::internal::op::unary< asin >, migraphx::internal::op::unary< asinh >, migraphx::internal::op::unary< atan >, migraphx::internal::op::unary< atanh >, migraphx::internal::op::unary< ceil >, migraphx::internal::op::unary< convert >, migraphx::internal::op::unary< cos >, migraphx::internal::op::unary< cosh >, migraphx::internal::op::unary< erf >, migraphx::internal::op::unary< exp >, migraphx::internal::op::unary< floor >, migraphx::internal::op::unary< isnan >, migraphx::internal::op::unary< log >, migraphx::internal::op::unary< neg >, migraphx::internal::op::unary< recip >, migraphx::internal::op::unary< relu >, migraphx::internal::op::unary< round >, migraphx::internal::op::unary< rsqrt >, migraphx::internal::op::unary< sigmoid >, migraphx::internal::op::unary< sign >, migraphx::internal::op::unary< sin >, migraphx::internal::op::unary< sinh >, migraphx::internal::op::unary< sqrt >, migraphx::internal::op::unary< tan >, migraphx::internal::op::unary< tanh >, migraphx::internal::op::unary< unary_not >, migraphx::internal::op::binary< Derived >, migraphx::internal::op::prefix_scan_op< Derived >, migraphx::internal::op::reduce_op< Derived >, migraphx::internal::op::scatter< Derived >, migraphx::internal::op::scatternd_op< Derived >, migraphx::internal::op::unary< Derived >

struct outline

#include <migraphx/op/outline.hpp>

struct pad

#include <migraphx/op/pad.hpp>

struct pointwise

#include <migraphx/op/pointwise.hpp>

struct pooling

#include <migraphx/op/pooling.hpp>

struct pow : public migraphx::internal::op::binary<pow>

#include <migraphx/op/pow.hpp>

template<class Derived>
struct prefix_scan_op : public migraphx::internal::op::op_name<Derived>

#include <migraphx/op/prefix_scan_op.hpp>

struct prefix_scan_sum : public migraphx::internal::op::prefix_scan_op<prefix_scan_sum>

#include <migraphx/op/prefix_scan_sum.hpp>

struct prelu : public migraphx::internal::op::binary<prelu>

#include <migraphx/op/prelu.hpp>

struct quant_convolution

#include <migraphx/op/quant_convolution.hpp>

struct quant_dot

#include <migraphx/op/quant_dot.hpp>

struct quantizelinear

#include <migraphx/op/quantizelinear.hpp>

struct recip : public migraphx::internal::op::unary<recip>

#include <migraphx/op/recip.hpp>

struct reduce_max : public migraphx::internal::op::reduce_op<reduce_max>

#include <migraphx/op/reduce_max.hpp>

struct reduce_mean : public migraphx::internal::op::reduce_op<reduce_mean>

#include <migraphx/op/reduce_mean.hpp>

struct reduce_min : public migraphx::internal::op::reduce_op<reduce_min>

#include <migraphx/op/reduce_min.hpp>

template<class Derived>
struct reduce_op : public migraphx::internal::op::op_name<Derived>

#include <migraphx/op/reduce_op.hpp>

struct reduce_prod : public migraphx::internal::op::reduce_op<reduce_prod>

#include <migraphx/op/reduce_prod.hpp>

struct reduce_sum : public migraphx::internal::op::reduce_op<reduce_sum>

#include <migraphx/op/reduce_sum.hpp>

struct relu : public migraphx::internal::op::unary<relu>

#include <migraphx/op/relu.hpp>

struct reshape

#include <migraphx/op/reshape.hpp>

struct reverse

#include <migraphx/op/reverse.hpp>

struct rnn

#include <migraphx/op/rnn.hpp>

struct rnn_last_cell_output

#include <migraphx/op/rnn_last_cell_output.hpp>

struct rnn_last_hs_output

#include <migraphx/op/rnn_last_hs_output.hpp>

struct rnn_var_sl_last_output

#include <migraphx/op/rnn_var_sl_last_output.hpp>

struct rnn_var_sl_shift_output

#include <migraphx/op/rnn_variable_seq_lens.hpp>

struct rnn_var_sl_shift_sequence

#include <migraphx/op/rnn_variable_seq_lens.hpp>

struct roialign

#include <migraphx/op/roialign.hpp>

struct round : public migraphx::internal::op::unary<round>

#include <migraphx/op/round.hpp>

struct rsqrt : public migraphx::internal::op::unary<rsqrt>

#include <migraphx/op/rsqrt.hpp>

struct scalar

#include <migraphx/op/scalar.hpp>

template<class Derived>
struct scatter : public migraphx::internal::op::op_name<Derived>

#include <migraphx/op/scatter.hpp>

struct scatter_add : public migraphx::internal::op::scatter<scatter_add>

#include <migraphx/op/scatter_add.hpp>

struct scatter_mul : public migraphx::internal::op::scatter<scatter_mul>

#include <migraphx/op/scatter_mul.hpp>

struct scatter_none : public migraphx::internal::op::scatter<scatter_none>

#include <migraphx/op/scatter_none.hpp>

struct scatternd_add : public migraphx::internal::op::scatternd_op<scatternd_add>

#include <migraphx/op/scatternd_add.hpp>

struct scatternd_mul : public migraphx::internal::op::scatternd_op<scatternd_mul>

#include <migraphx/op/scatternd_mul.hpp>

struct scatternd_none : public migraphx::internal::op::scatternd_op<scatternd_none>

#include <migraphx/op/scatternd_none.hpp>

template<class Derived>
struct scatternd_op : public migraphx::internal::op::op_name<Derived>

#include <migraphx/op/scatternd_op.hpp>

struct sigmoid : public migraphx::internal::op::unary<sigmoid>

#include <migraphx/op/sigmoid.hpp>

struct sign : public migraphx::internal::op::unary<sign>

#include <migraphx/op/sign.hpp>

struct sin : public migraphx::internal::op::unary<sin>

#include <migraphx/op/sin.hpp>

struct sinh : public migraphx::internal::op::unary<sinh>

#include <migraphx/op/sinh.hpp>

struct slice

#include <migraphx/op/slice.hpp>

struct softmax

#include <migraphx/op/softmax.hpp>

struct sqdiff : public migraphx::internal::op::binary<sqdiff>

#include <migraphx/op/sqdiff.hpp>

struct sqrt : public migraphx::internal::op::unary<sqrt>

#include <migraphx/op/sqrt.hpp>

struct squeeze

#include <migraphx/op/squeeze.hpp>

struct step

#include <migraphx/op/step.hpp>

struct sub : public migraphx::internal::op::binary<sub>

#include <migraphx/op/sub.hpp>

struct tan : public migraphx::internal::op::unary<tan>

#include <migraphx/op/tan.hpp>

struct tanh : public migraphx::internal::op::unary<tanh>

#include <migraphx/op/tanh.hpp>

struct topk

#include <migraphx/op/topk.hpp>

struct transpose

#include <migraphx/op/transpose.hpp>

template<class Derived>
struct unary : public migraphx::internal::op::op_name<Derived>

#include <migraphx/op/unary.hpp>

struct unary_not : public migraphx::internal::op::unary<unary_not>

#include <migraphx/op/unary_not.hpp>

struct undefined

#include <migraphx/op/undefined.hpp>

struct unknown

#include <migraphx/op/unknown.hpp>

struct unsqueeze

#include <migraphx/op/unsqueeze.hpp>

struct where

#include <migraphx/op/where.hpp>

struct zero

#include <migraphx/op/reduce_op.hpp>