arm_compute::experimental::dynamic_fusion Namespace Reference

Data Structures
class	ArgumentPack
	This is a generic class that packs the arguments of an operator. More...
struct	AuxMemoryInfo
	Memory information for tensors with MemoryType::Auxiliary. More...
class	CastAttributes
	Attributes are backend-agnostic parameters (in addition to the input/output tensors) of an operator. More...
class	ClampAttributes
	Attributes are backend-agnostic parameters (in addition to the input/output tensors) of an operator. More...
class	ClComponentActivation
class	ClComponentCast
class	ClComponentCastSettings
	Component specific settings. More...
class	ClComponentDepthwiseConv2d
class	ClComponentDepthwiseConv2dSettings
	Component specific settings. More...
class	ClComponentDirectConv2d
class	ClComponentDirectConv2dSettings
	Component specific settings. More...
class	ClComponentElementwiseBinary
class	ClComponentLogits1DMaxShiftExpSum
	Component to calculate max-shifted exponentials and their sum. More...
class	ClComponentLogits1DNorm
	Component to calculate the final step of the Softmax Layer where each logit value is multiplied by the inverse of the sum of the logits. More...
class	ClComponentMatMul
class	ClComponentPool2d
class	ClComponentReshape
class	ClComponentResize
class	ClComponentStore
class	ClKernelRuntime
	OpenCL runtime to run a single kernel. More...
class	ClTemplateActivation
class	ClTemplateCast
class	ClTemplateDepthwiseConv2d
class	ClTemplateDirectConv2d
class	ClTemplateElementwiseBinary
class	ClTemplateLogits1DMaxShiftExpSum
class	ClTemplateLogits1DNorm
class	ClTemplatePool2d
class	ClTemplateReshape
class	ClTemplateResize
class	ClTemplateStore
class	ClTemplateWriter
	Use a templated-string-based method to write kernel code It stitches the component code templates together based on the valid fusion configuration. More...
class	ClWorkloadRuntime
	OpenCL runtime to run a workload. More...
class	Conv2dAttributes
	Attributes are backend-agnostic parameters (in addition to the input/output tensors) of an operator. More...
class	DependencyGraph
	A multi-input (tensors), multi-output (tensors) acyclic directed graph Represented as a doubly-linked adjacency list with the differentiation between source and destination. More...
class	DepthwiseConv2dAttributes
	Attributes are backend-agnostic parameters (in addition to the input/output tensors) of an operator. More...
class	ElementwiseBinaryCommonAttributes
class	GpuAdd
	Operator interface. More...
class	GpuCast
	Operator interface. More...
class	GpuCkwActivation
class	GpuCkwCast
class	GpuCkwComponentArgument
	The argument of a dynamic fusion component which can be either user tensor or virtual tensor. More...
class	GpuCkwDepthwiseConv2d
class	GpuCkwDirectConv2d
class	GpuCkwDriver
	Use Kernel Writer to write kernel code Used by dynamic_fusion module. More...
class	GpuCkwElementwiseBinary
class	GpuCkwKernelWriter
	Extended implementation of kernel writer for dynamic fusion. More...
class	GpuCkwMatMul
class	GpuCkwPool2d
class	GpuCkwResize
class	GpuCkwScopedKernelWriter
	Helper to automatically manage kernel writer ID space. More...
class	GpuCkwStore
	An interface used by ClTemplateWriter to write source code for a kernel component. More...
class	GpuCkwVariableTable
	A table of all the variables used in the kernel. More...
class	GpuClamp
	Operator interface. More...
class	GpuComponentServices
	Services that are used throughout the creation phase of workload code. More...
class	GpuConv2d
	Operator interface. More...
class	GpuDepthwiseConv2d
	Operator interface. More...
class	GpuElementwiseBinaryCommon
	Operator interface. More...
class	GpuKernelArgument
	Kernel argument information linked with its corresponding ITensorInfo. More...
struct	GpuKernelArgumentInfo
	Contain information required to set up a kernel argument at run time. More...
class	GpuKernelComponentFactory
	Factory class that creates new instances of IGpuKernelComponent by assigning new component ids. More...
class	GpuKernelComponentGraph
	A multi-input (tensors), multi-output (tensors) acyclic directed graph of gpu kernel components Its main purposes are: More...
class	GpuKernelComponentGroup
	A group of gpu kernel components to be fused together PRECONDITIONS: More...
class	GpuKernelComponentStream
	A linear sequence of component groups serialized from the GpuKernelComponentGraph Each component group in the stream denotes a complete kernel that may consist of multiple components. More...
class	GpuKernelSourceCode
	Container of kernel code to be compiled and run in a GpuUnitWorkload. More...
class	GpuKernelVariableTable
	A table of all the variables used in the kernel. More...
class	GpuLogicalKernel
	A wrapper-processor of a GpuKernelComponentGroup It adds the load (if any) and store components to the component group The GpuLogicalKernel represents a complete kernel, and can proceed to invoke any kernel writer to generate the full kernel code. More...
class	GpuMatMul
	Operator interface. More...
class	GpuMatMulSettings
	Operator backend specific settings. More...
class	GpuMul
	Operator interface. More...
class	GpuOperatorGroup
	A linear sequence of operators to be fused in a workload For the time being, this class is only used for validating operator fusion INVARIANTS: More...
class	GpuOutput
	Operator interface. More...
class	GpuPool2d
	Operator interface. More...
class	GpuPool2dSettings
	Operator backend specific settings. More...
class	GpuReshape
	Operator interface. More...
class	GpuResize
	Operator interface. More...
class	GpuSigmoid
	Operator interface. More...
class	GpuSoftmax
	Operator interface. More...
class	GpuSub
	Operator interface. More...
class	GpuTanh
	Operator interface. More...
class	GpuUnitWorkload
	The atomic unit in a Gpu workload. More...
class	GpuWorkloadArgument
	Describes all the info related to a workload argument (tensor) in order to: More...
class	GpuWorkloadContext
	Provide context necessary for the creation and configuration of a workload e.g. More...
class	GpuWorkloadSketch
	A descriptor of a workload of operators. More...
class	GpuWorkloadSourceCode
	Hold the generated kernel source code and other information required to compile and run the workload. More...
class	IGpuCkwComponentDriver
	An interface used by GpuCkwDriver to write source code for a kernel component. More...
class	IGpuKernelComponent
	An abstract interface of a component. More...
class	IGpuKernelWriter
	An interface that can write a gpu kernel. More...
class	IGpuTemplateComponentWriter
	An interface used by ClTemplateWriter to write source code for a kernel component. More...
class	KernelProperties
	Properties common to all kernel component types. More...
class	MatMulAttributes
	Attributes are backend-agnostic parameters (in addition to the input/output tensors) of an operator. More...
struct	MemoryDescriptor
	Descriptor of a workload tensor memory. More...
class	Operator
	An operator for the sole purpose of validating fusion. More...
class	Pool2dAttributes
	Attributes are backend-agnostic parameters (in addition to the input/output tensors) of an operator. More...
class	ReshapeAttributes
	Attributes are backend-agnostic parameters (in addition to the input/output tensors) of an operator. More...
class	ResizeAttributes
	Attributes are backend-agnostic parameters (in addition to the input/output tensors) of an operator. More...
class	SoftmaxAttributes
	Attributes are backend-agnostic parameters (in addition to the input/output tensors) of an operator. More...
struct	TagVal
	A tag value will substitute a tag in a string template during its instantiation. More...
struct	UnitWorkloadStage
	Describes when a unit workload is run. More...

Typedefs
using	GpuTarget = ::arm_compute::GPUTarget
	Gpu Information such as the Gpu target (for example, G76) More...
using	MemoryDescriptorMap = std::map< ITensorInfo::Id, MemoryDescriptor >
	A map from ITensorInfo to their corresponding MemoryDescriptor. More...
using	TileContainer = std::vector< std::vector< std::string > >
using	SamplerCreator = std::function< TensorTileSampler(GpuCkwScopedKernelWriter &, int32_t, int32_t)>
using	Settings = ClComponentDepthwiseConv2dSettings
using	ComponentId = int32_t
	Uniquely identifies a kernel component within a workload. More...
using	GpuKernelArgumentList = std::map< ITensorInfo::Id, GpuKernelArgument >
	The argument list of a GpuKernelSourceCode. More...
using	OperatorId = DependencyGraph::OperatorId
using	UnitWorkloadId = int32_t
	Uniquely identifies a GpuUnitWorkload within a GpuWorkloadSourceCode. More...
using	Tag = std::string
	A tag used in a string template is a placeholder string to be substituted by real values during template instantiation. More...
using	TagLUT = std::unordered_map< Tag, TagVal >
	Tag lookup table. More...

Enumerations
enum	GpuLanguage { OpenCL, Unknown }
	Gpu Language. More...
enum	MemoryType { User = 0, Auxiliary, Virtual }
	Type of memory used by a workload tensor. More...
enum	GpuComponentType { Complex, Simple, Unfusable, Output }
	Component type in the context of fusion Its main purpose is to inform the optimizer how to perform fusion. More...
enum	GpuOperatorType { Simple, Complex, Unfusable }
	Contain properties common to all operator types. More...

Functions
void	cl_add_tensor_component_argument (cl::Kernel &kernel, unsigned int &idx, const ICLTensor *tensor, TensorComponentType component)
	Select a Compute Kernel Writer tensor component from a tensor and add to the kernel's arguments at the specified index idx. More...
void	cl_add_buffer_argument (cl::Kernel &kernel, unsigned int &idx, const cl::Buffer &buffer)
	Add an OpenCL buffer object to the kernel's arguments at the specified index idx. More...
void	cl_add_texture_argument (cl::Kernel &kernel, unsigned int &idx, const cl::Image &image)
	Add an OpenCL image object to the kernel's arguments at the specified index idx. More...
ckw::DataType	to_ckw (DataType dt)
ckw::TensorShape	to_ckw (const TensorShape &shape)
ckw::TensorDataLayout	to_ckw (DataLayout dl)
ckw::TensorInfo	to_ckw (const ITensorInfo &tensor_info)
TensorComponentType	from_ckw (const ckw::TensorComponentType &component)
ckw::TensorStorageType	to_ckw (const TensorStorageType &storage)
TensorStorageType	from_ckw (const ckw::TensorStorageType &storage)
ckw::BinaryOp	to_ckw (const ElementwiseBinaryCommonAttributes &attributes)
void	load_src_dst_tiles_and_prepare_sampler (GpuCkwScopedKernelWriter &writer, GpuCkwComponentArgument *src, GpuCkwComponentArgument *dst, int32_t m0, int32_t n0, SamplerCreator create_sampler)
	Load src and dst tiles of dimension [m0, n0] only when not loaded and prepare the sampler. More...
void	get_coord (GpuCkwScopedKernelWriter writer, TileOperand &coord, const TileOperand &gid, int32_t step_v, int32_t leftover_step_v, const std::string &prefix, const TileOperand &const_0)
	Get boundary aware coordinate along one axis. More...
TensorTileSampler	create_boundary_aware_2d_sampler (GpuCkwScopedKernelWriter writer, TileOperand &gid_0, TileOperand &gid_1, int32_t dim0_v, int32_t dim1_v, int32_t n0_v, int32_t m0_v, const std::string prefix, TileOperand &const_0)
	Declare coordinate tiles "{prefix}_dim0_coord" and "{prefix}_dim1_coord", and create a boundary-aware sampler from tile of size [n0, m0], against the overall dimensions [dim0, dim1] The load and store of tile [n0, m0] will never be out of bound of [dim0, dim1]. More...
bool	operator== (const KernelProperties &config0, const KernelProperties &config1)
bool	operator== (const GpuKernelArgumentInfo &info0, const GpuKernelArgumentInfo &info1)
bool	operator== (const UnitWorkloadStage &stage0, const UnitWorkloadStage &stage1)
bool	is_alloc_tensor (const ITensorInfo *tensor_info)
	Tensor should have backing memory. More...
bool	is_noalloc_tensor (const ITensorInfo *tensor_info)
	Tensor should not have backing memory. More...
bool	is_valid_tensor (const ITensorInfo *tensor_info)
	ITensorInfo has valid id More...
bool	is_invalid_tensor (const ITensorInfo *tensor_info)
	ITensorInfo has invalid id More...
PoolingLayerInfo	convert_pool_attr_to_pool_info (const Pool2dAttributes &pool_attr, bool mixed_precision=false, DataLayout data_layout=DataLayout::NHWC)
	Inline function to convert Pool2dAttributes to PoolingLayerInfo. More...

Variables
constexpr unsigned int	vector_size_byte_opencl = 16

Typedef Documentation

ComponentId

using ComponentId = int32_t

Uniquely identifies a kernel component within a workload.

Definition at line 37 of file Types.h.

GpuKernelArgumentList

using GpuKernelArgumentList = std::map<ITensorInfo::Id, GpuKernelArgument>

The argument list of a GpuKernelSourceCode.

Definition at line 47 of file GpuKernelSourceCode.h.

GpuTarget

using GpuTarget = ::arm_compute::GPUTarget

Gpu Information such as the Gpu target (for example, G76)

Definition at line 41 of file GpuWorkloadContext.h.

MemoryDescriptorMap

using MemoryDescriptorMap = std::map<ITensorInfo::Id, MemoryDescriptor>

A map from ITensorInfo to their corresponding MemoryDescriptor.

Definition at line 91 of file MemoryDescriptor.h.

OperatorId

using OperatorId = DependencyGraph::OperatorId

Definition at line 41 of file GpuOperatorGroup.h.

SamplerCreator

using SamplerCreator = std::function<TensorTileSampler(GpuCkwScopedKernelWriter &, int32_t , int32_t )>

Definition at line 44 of file WriterHelper.h.

Settings

using Settings = ClComponentDepthwiseConv2dSettings

Definition at line 43 of file ClComponentDepthwiseConv2d.cpp.

Tag

using Tag = std::string

A tag used in a string template is a placeholder string to be substituted by real values during template instantiation.

Definition at line 127 of file GpuKernelVariableTable.h.

TagLUT

using TagLUT = std::unordered_map<Tag, TagVal>

Tag lookup table.

It is used to instantiate a string template

Definition at line 130 of file GpuKernelVariableTable.h.

TileContainer

using TileContainer = std::vector<std::vector<std::string> >

Definition at line 50 of file GpuCkwDirectConv2d.cpp.

UnitWorkloadId

using UnitWorkloadId = int32_t

Uniquely identifies a GpuUnitWorkload within a GpuWorkloadSourceCode.

Definition at line 75 of file GpuWorkloadSourceCode.h.

Enumeration Type Documentation

GpuComponentType

enum GpuComponentType

strong

Component type in the context of fusion Its main purpose is to inform the optimizer how to perform fusion.

Enumerator
Complex
Simple
Unfusable
Output

Definition at line 42 of file Types.h.

{
    Complex,
    Simple,
    Unfusable,
    Output
};

GpuLanguage

enum GpuLanguage

strong

Gpu Language.

Enumerator
OpenCL
Unknown

Definition at line 44 of file GpuWorkloadContext.h.

{
    OpenCL,
    Unknown
};

GpuOperatorType

enum GpuOperatorType

strong

Contain properties common to all operator types.

Operator type in the context of fusion

Enumerator
Simple	Simple operators are operators that: Have a 1-to-1 mapping between the input elements and output elements, like elementwise Have exactly 1 output
Complex	Complex operators are operators that are not simple but are still fusable with simple ones.
Unfusable	Unfusable operators are operators that cannot be fused with any other types of operators.

Definition at line 37 of file GpuOperatorProperties.h.

{
    /** Simple operators are operators that:
     *  1. Have a 1-to-1 mapping between the input elements and output elements, like elementwise
     *  2. Have exactly 1 output
     */
    Simple,
    /** Complex operators are operators that are not simple but are still fusable with simple ones
     */
    Complex,
    /** Unfusable operators are operators that cannot be fused with any other types of operators
     */
    Unfusable
};

MemoryType

enum MemoryType

strong

Type of memory used by a workload tensor.

We can classify tensors in 2 dimensions: Topology (where they are in a workload) and Memory allocation: Topology: Argument tensors: "Outer" tensors exposed to the users as inputs and outputs (arguments) Intermediate tensors: "Inner" tensors hidden from the users as links between operators Memory allocation: Alloc: Tensors that need to be allocated real backing memory No-Alloc: Tensors that don't need to be allocated real backing memory

We end up with 3 MemoryType based on the product of these two classifications | Argument | Intermediate | ------—*-------------—*----------------—* Alloc | User | Auxiliary | ------—*-------------—*----------------—* No-Alloc * N/A | Virtual | ------—*-------------—*----------------—*

Enumerator
User	Both User and Auxiliary types are of Alloc type. Since they require memory allocation Memory coming directly from users, e.g. for argument tensors
Auxiliary	Additional memory required by the workload tensor, e.g. for tensors holding temporary results between kernels
Virtual	Virtual type is of No-Alloc type. Since it doesn't require memory allocation Temporary tile which is not allocated as a whole tensor in the memory. It is mainly used at sketch time to link operators; there should be no Virtual tensors at runtime

Definition at line 53 of file MemoryDescriptor.h.

{
    /** Both User and Auxiliary types are of Alloc type. Since they require memory allocation */
    User = 0, /**< Memory coming directly from users, e.g. for argument tensors */
    Auxiliary =
        1, /**< Additional memory required by the workload tensor, e.g. for tensors holding temporary results between kernels */
    /** Virtual type is of No-Alloc type. Since it doesn't require memory allocation */
    Virtual =
        2, /**< Temporary tile which is not allocated as a whole tensor in the memory. It is mainly used at sketch time to link operators; there should be no Virtual tensors at runtime */
};

Function Documentation

cl_add_buffer_argument()

void cl_add_buffer_argument	(	cl::Kernel &	kernel,
		unsigned int &	idx,
		const cl::Buffer &	buffer
	)

Add an OpenCL buffer object to the kernel's arguments at the specified index idx.

Parameters

[in,out]	kernel	OpenCL kernel to configure with the provided argument.
[in,out]	idx	Index at which to add the argument.
[in]	buffer	OpenCL buffer containing the tensor's data.

Definition at line 93 of file GpuCkwKernelArgumentsHelpers.cpp.

{
    kernel.setArg(idx++, buffer);
}

cl_add_tensor_component_argument()

void cl_add_tensor_component_argument	(	cl::Kernel &	kernel,
		unsigned int &	idx,
		const ICLTensor *	tensor,
		TensorComponentType	component
	)

Select a Compute Kernel Writer tensor component from a tensor and add to the kernel's arguments at the specified index idx.

Parameters

[in,out]	kernel	OpenCL kernel to configure with the provided argument.
[in,out]	idx	Index at which to add the argument.
[in]	tensor	Tensor from which to access the tensor component.
[in]	component	Tensor component to select such as tensor dimensions, strides, etc.

Definition at line 33 of file GpuCkwKernelArgumentsHelpers.cpp.

{
    ARM_COMPUTE_ERROR_ON(tensor == nullptr);
 
    const auto *info    = tensor->info();
    const auto &strides = info->strides_in_bytes();
 
    switch (component)
    {
        case TensorComponentType::OffsetFirstElement:
            kernel.setArg<cl_uint>(idx++, info->offset_first_element_in_bytes());
            break;
        case TensorComponentType::Stride0:
            kernel.setArg<cl_uint>(idx++, strides[0]);
            break;
        case TensorComponentType::Stride1:
            kernel.setArg<cl_uint>(idx++, strides[1]);
            break;
        case TensorComponentType::Stride2:
            kernel.setArg<cl_uint>(idx++, strides[2]);
            break;
        case TensorComponentType::Stride3:
            kernel.setArg<cl_uint>(idx++, strides[3]);
            break;
        case TensorComponentType::Stride4:
            kernel.setArg<cl_uint>(idx++, strides[4]);
            break;
        case TensorComponentType::Dim0:
            kernel.setArg<cl_uint>(idx++, info->dimension(0));
            break;
        case TensorComponentType::Dim1:
            kernel.setArg<cl_uint>(idx++, info->dimension(1));
            break;
        case TensorComponentType::Dim2:
            kernel.setArg<cl_uint>(idx++, info->dimension(2));
            break;
        case TensorComponentType::Dim3:
            kernel.setArg<cl_uint>(idx++, info->dimension(3));
            break;
        case TensorComponentType::Dim4:
            kernel.setArg<cl_uint>(idx++, info->dimension(4));
            break;
        case TensorComponentType::Dim1xDim2:
            kernel.setArg<cl_uint>(idx++, info->dimension(1) * info->dimension(2));
            break;
        case TensorComponentType::Dim2xDim3:
            kernel.setArg<cl_uint>(idx++, info->dimension(2) * info->dimension(3));
            break;
        case TensorComponentType::Dim1xDim2xDim3:
            kernel.setArg<cl_uint>(idx++, info->dimension(1) * info->dimension(2) * info->dimension(3));
            break;
        case TensorComponentType::Unknown:
        default:
            ARM_COMPUTE_ERROR("Unknown tensor component");
    }
}

References ARM_COMPUTE_ERROR, ARM_COMPUTE_ERROR_ON, arm_compute::test::validation::info, and tensor.

cl_add_texture_argument()

void cl_add_texture_argument	(	cl::Kernel &	kernel,
		unsigned int &	idx,
		const cl::Image &	image
	)

Add an OpenCL image object to the kernel's arguments at the specified index idx.

Parameters

[in,out]	kernel	OpenCL kernel to configure with the provided argument.
[in,out]	idx	Index at which to add the argument.
[in]	image	OpenCL image containing the image's data.

Definition at line 98 of file GpuCkwKernelArgumentsHelpers.cpp.

{
    kernel.setArg(idx++, image);
}

References caffe_mnist_image_extractor::image.

convert_pool_attr_to_pool_info()

PoolingLayerInfo arm_compute::experimental::dynamic_fusion::convert_pool_attr_to_pool_info ( const Pool2dAttributes &  pool_attr, bool  mixed_precision = false, DataLayout  data_layout = DataLayout::NHWC  )

inline

Inline function to convert Pool2dAttributes to PoolingLayerInfo.

Definition at line 66 of file Utils.h.

{
    // Create PadStrideInfo
    const Size2D        stride  = pool_attr.stride();
    const Padding2D     padding = pool_attr.pad();
    const PadStrideInfo pad_stride(stride.x(), stride.y(), padding.left, padding.top,
                                   arm_compute::DimensionRoundingType::FLOOR);
 
    return PoolingLayerInfo(pool_attr.pool_type(), pool_attr.pool_size(), data_layout, pad_stride,
                            pool_attr.exclude_padding(), mixed_precision);
}

References arm_compute::cpu::data_layout, Pool2dAttributes::exclude_padding(), arm_compute::FLOOR, Padding2D::left, Pool2dAttributes::pad(), Pool2dAttributes::pool_size(), Pool2dAttributes::pool_type(), Pool2dAttributes::stride(), Padding2D::top, Size2D::x(), and Size2D::y().

Referenced by ClComponentPool2d::validate().

create_boundary_aware_2d_sampler()

TensorTileSampler arm_compute::experimental::dynamic_fusion::create_boundary_aware_2d_sampler ( GpuCkwScopedKernelWriter  writer, TileOperand &  gid_0, TileOperand &  gid_1, int32_t  dim0_v, int32_t  dim1_v, int32_t  n0_v, int32_t  m0_v, const std::string  prefix, TileOperand &  const_0  )

inline

Declare coordinate tiles "{prefix}_dim0_coord" and "{prefix}_dim1_coord", and create a boundary-aware sampler from tile of size [n0, m0], against the overall dimensions [dim0, dim1] The load and store of tile [n0, m0] will never be out of bound of [dim0, dim1].

Declare coordinate tiles "{prefix}_dim0_coord" and "{prefix}_dim1_coord", and create a boundary-aware sampler from tile of size [n0, m0], against the overall dimensions [dim0, dim1] The load and store of tile [n0, m0] will never be out of bound of [dim0, dim1]

Parameters

[in,out]	writer	Writer
[in]	gid_0	Global work item id 0
[in]	gid_1	Global work item id 1
[in]	dim0_v	Dimension 0
[in]	dim1_v	Dimension 1
[in]	n0_v	Tile size dimension 0
[in]	m0_v	Tile size dimension 1
[in]	prefix	Prefix to all the tiles declared within this function
[in]	const_0	Constant tile of value 0

Returns

TensorTileSampler

Definition at line 137 of file WriterHelper.h.

{
    // Clamp tile size [n0, m0] against dimension [dim0, dim1]
    // This is needed to:
    // * Guard against tile sizes are bigger than the tensor dimensions
    // * Handle broadcasting tiles (e.g. src tensor is of size 1 in one of the dimensions)
    n0_v                       = utility::clamp(n0_v, 1, dim0_v);
    m0_v                       = utility::clamp(m0_v, 1, dim1_v);
    const int32_t partial_n0_v = dim0_v % n0_v;
    const int32_t partial_m0_v = dim1_v % m0_v;
 
    // Declare #prefix_dim0_coord and #prefix_dim1_coord
    auto &dim0_coord = writer->declare_tile(prefix + "dim0_coord", ckw::DataType::Int32);
    get_coord(writer, dim0_coord, gid_0, n0_v, partial_n0_v, prefix + "dim0_", const_0);
    auto &dim1_coord = writer->declare_tile(prefix + "dim1_coord", ckw::DataType::Int32);
    get_coord(writer, dim1_coord, gid_1, m0_v, partial_m0_v, prefix + "dim1_", const_0);
 
    // Set sampler
    // Only set fields related to boundary aware loading/storing. Other info (e.g. format) is not responsibility of this function
    TensorTileSampler sampler;
 
    sampler.x(dim0_coord);
    sampler.y(dim1_coord);
 
    sampler.width(n0_v);
    sampler.height(m0_v);
 
    sampler.address_mode_x(TensorSamplerAddressModeX::None);
    sampler.address_mode_y(TensorSamplerAddressModeY::None);
    sampler.address_mode_z(TensorSamplerAddressModeZ::None);
 
    return sampler;
}

References arm_compute::utility::clamp(), get_coord(), tf_frozen_model_extractor::None, and check_header_guards::prefix.

Referenced by GpuCkwElementwiseBinary::write_component_code().

from_ckw() [1/2]

TensorComponentType arm_compute::experimental::dynamic_fusion::from_ckw ( const ckw::TensorComponentType &  component )

inline

Definition at line 94 of file Common.h.

{
    switch (component)
    {
        case ckw::TensorComponentType::OffsetFirstElement:
            return TensorComponentType::OffsetFirstElement;
        case ckw::TensorComponentType::Stride0:
            return TensorComponentType::Stride0;
        case ckw::TensorComponentType::Stride1:
            return TensorComponentType::Stride1;
        case ckw::TensorComponentType::Stride2:
            return TensorComponentType::Stride2;
        case ckw::TensorComponentType::Stride3:
            return TensorComponentType::Stride3;
        case ckw::TensorComponentType::Stride4:
            return TensorComponentType::Stride4;
        case ckw::TensorComponentType::Dim0:
            return TensorComponentType::Dim0;
        case ckw::TensorComponentType::Dim1:
            return TensorComponentType::Dim1;
        case ckw::TensorComponentType::Dim2:
            return TensorComponentType::Dim2;
        case ckw::TensorComponentType::Dim3:
            return TensorComponentType::Dim3;
        case ckw::TensorComponentType::Dim4:
            return TensorComponentType::Dim4;
        case ckw::TensorComponentType::Dim1xDim2:
            return TensorComponentType::Dim1xDim2;
        case ckw::TensorComponentType::Dim2xDim3:
            return TensorComponentType::Dim2xDim3;
        case ckw::TensorComponentType::Dim1xDim2xDim3:
            return TensorComponentType::Dim1xDim2xDim3;
        case ckw::TensorComponentType::Unknown:
            return TensorComponentType::Unknown;
        default:
            ARM_COMPUTE_ERROR("Unknown CKW tensor component");
            return TensorComponentType::Unknown;
    }
}

References ARM_COMPUTE_ERROR.

Referenced by GpuCkwDriver::get_kernel_arguments().

from_ckw() [2/2]

TensorStorageType arm_compute::experimental::dynamic_fusion::from_ckw ( const ckw::TensorStorageType &  storage )

inline

Definition at line 151 of file Common.h.

{
    switch (storage)
    {
        case ckw::TensorStorageType::BufferUint8Ptr:
            return TensorStorageType::ClBufferUint8Ptr;
        case ckw::TensorStorageType::Texture2dReadOnly:
            return TensorStorageType::ClImage2dReadOnly;
        case ckw::TensorStorageType::Texture2dWriteOnly:
            return TensorStorageType::ClImage2dWriteOnly;
        case ckw::TensorStorageType::Unknown:
            return TensorStorageType::Unknown;
        default:
            ARM_COMPUTE_ERROR("Unknown CKW tensor storage type");
            return TensorStorageType::Unknown;
    }
}

References ARM_COMPUTE_ERROR.

get_coord()

void arm_compute::experimental::dynamic_fusion::get_coord ( GpuCkwScopedKernelWriter  writer, TileOperand &  coord, const TileOperand &  gid, int32_t  step_v, int32_t  leftover_step_v, const std::string &  prefix, const TileOperand &  const_0  )

inline

Get boundary aware coordinate along one axis.

Load and store of size step_v at the coordinate will not be out of bound

Parameters

[in,out]	writer	Writer
[out]	coord	Resultant coordinate
[in]	gid	Global work item id
[in]	step_v	Step size / vector size
[in]	leftover_step_v	Leftover step size at the boundary
[in]	prefix	Prefix to all the tiles declared within this function
[in]	const_0	Constant tile of value 0

Definition at line 87 of file WriterHelper.h.

{
    auto &step          = writer->declare_tile(prefix + "step", step_v);
    auto &leftover_step = writer->declare_tile(prefix + "leftover_step", leftover_step_v);
 
    // step - leftover_step
    auto &step_minus_leftover = writer->declare_tile(prefix + "step_minus_leftover", ckw::DataType::Int32);
    writer->op_binary_expression(step_minus_leftover, step, ckw::BinaryOp::Sub, leftover_step);
 
    // (step - leftover_step) % step
    auto &coord_correction = writer->declare_tile(prefix + "coord_correction", ckw::DataType::Int32);
    writer->op_binary_expression(coord_correction, step_minus_leftover, ckw::BinaryOp::Mod, step);
 
    // (gid * step)
    auto &raw_coord = writer->declare_tile(prefix + "raw_coord", ckw::DataType::Int32);
    writer->op_binary_expression(raw_coord, gid, ckw::BinaryOp::Mul, step);
 
    // (gid * step) - (step - leftover_step) % step
    auto &corrected_coord = writer->declare_tile(prefix + "corrected_coord", ckw::DataType::Int32);
    writer->op_binary_expression(corrected_coord, raw_coord, ckw::BinaryOp::Sub, coord_correction);
 
    // max((gid * step) - (step - leftover_step) % step, 0)
    writer->op_binary_elementwise_function(coord, ckw::BinaryFunction::Max, corrected_coord, const_0);
}

References check_header_guards::prefix, and arm_compute::cpu::step.

Referenced by create_boundary_aware_2d_sampler(), GpuCkwPool2d::write_component_code(), GpuCkwDepthwiseConv2d::write_component_code(), GpuCkwMatMul::write_component_code(), and GpuCkwDirectConv2d::write_component_code().

is_alloc_tensor()

bool arm_compute::experimental::dynamic_fusion::is_alloc_tensor ( const ITensorInfo *  tensor_info )

inline

Tensor should have backing memory.

MemoryType

Definition at line 38 of file Utils.h.

{
    return tensor_info->id() > ITensorInfo::invalid_tensor_id;
}

References ITensorInfo::invalid_tensor_id, and tensor_info.

Referenced by GpuOutput::validate_op().

is_invalid_tensor()

bool arm_compute::experimental::dynamic_fusion::is_invalid_tensor ( const ITensorInfo *  tensor_info )

inline

ITensorInfo has invalid id

Definition at line 59 of file Utils.h.

{
    return !is_valid_tensor(tensor_info);
}

References is_valid_tensor(), and tensor_info.

is_noalloc_tensor()

bool arm_compute::experimental::dynamic_fusion::is_noalloc_tensor ( const ITensorInfo *  tensor_info )

inline

Tensor should not have backing memory.

MemoryType

Definition at line 45 of file Utils.h.

{
    return tensor_info->id() < ITensorInfo::invalid_tensor_id;
}

References ITensorInfo::invalid_tensor_id, and tensor_info.

is_valid_tensor()

bool arm_compute::experimental::dynamic_fusion::is_valid_tensor ( const ITensorInfo *  tensor_info )

inline

ITensorInfo has valid id

Definition at line 52 of file Utils.h.

{
    return tensor_info->has_valid_id();
}

References tensor_info.

Referenced by is_invalid_tensor().

load_src_dst_tiles_and_prepare_sampler()

void arm_compute::experimental::dynamic_fusion::load_src_dst_tiles_and_prepare_sampler ( GpuCkwScopedKernelWriter &  writer, GpuCkwComponentArgument *  src, GpuCkwComponentArgument *  dst, int32_t  m0, int32_t  n0, SamplerCreator  create_sampler  )

inline

Load src and dst tiles of dimension [m0, n0] only when not loaded and prepare the sampler.

Definition at line 48 of file WriterHelper.h.

{
    if (!src->has_tile())
    {
        const auto sampler = create_sampler(writer, m0, n0);
        writer->op_load_once(src, sampler);
    }
    else
    {
        const auto &sampler = src->tile_sampler();
        writer->op_load_once(src, sampler);
    }
 
    auto       &src_tile = src->tile();
    const auto &sampler  = src->tile_sampler();
 
    // Prepare the output tile.
    if (!dst->has_tile())
    {
        auto &tile = writer->declare_tile("dst_tile", src_tile.tile_info());
        dst->init_virtual_tensor(tile, sampler);
    }
}

References arm_compute::test::validation::dst, GpuCkwKernelWriter::op_load_once(), arm_compute::test::validation::src, and arm_compute::test::validation::reference::tile().

Referenced by GpuCkwActivation::write_component_code().

operator==() [1/3]

bool operator==	(	const GpuKernelArgumentInfo &	info0,
		const GpuKernelArgumentInfo &	info1
	)

Definition at line 31 of file GpuKernelArgument.cpp.

{
    return info0.type == info1.type;
}

References GpuKernelArgumentInfo::type.

operator==() [2/3]

bool arm_compute::experimental::dynamic_fusion::operator== ( const KernelProperties &  config0, const KernelProperties &  config1  )

inline

Definition at line 56 of file IGpuKernelComponent.h.

{
    return config0.stage() == config1.stage();
}

References KernelProperties::stage().

operator==() [3/3]

bool arm_compute::experimental::dynamic_fusion::operator== ( const UnitWorkloadStage &  stage0, const UnitWorkloadStage &  stage1  )

inline

Definition at line 193 of file GpuWorkloadSourceCode.h.

{
    return stage0.stage == stage1.stage;
}

References UnitWorkloadStage::stage.

to_ckw() [1/6]

ckw::BinaryOp arm_compute::experimental::dynamic_fusion::to_ckw ( const ElementwiseBinaryCommonAttributes &  attributes )

inline

Definition at line 37 of file ElementwiseBinary.h.

{
    switch (attributes.operation())
    {
        case ElementwiseBinaryCommonAttributes::ElementwiseOp::Add:
            return ckw::BinaryOp::Add;
        case ElementwiseBinaryCommonAttributes::ElementwiseOp::Sub:
            return ckw::BinaryOp::Sub;
        case ElementwiseBinaryCommonAttributes::ElementwiseOp::Div:
            return ckw::BinaryOp::Div;
        case ElementwiseBinaryCommonAttributes::ElementwiseOp::Mul:
            return ckw::BinaryOp::Mul;
        case ElementwiseBinaryCommonAttributes::ElementwiseOp::Min:
        case ElementwiseBinaryCommonAttributes::ElementwiseOp::Max:
        case ElementwiseBinaryCommonAttributes::ElementwiseOp::Power:
        case ElementwiseBinaryCommonAttributes::ElementwiseOp::Prelu:
        case ElementwiseBinaryCommonAttributes::ElementwiseOp::SquaredDiff:
        default:
            ARM_COMPUTE_ERROR("Cannot convert ElementwiseBinaryCommonAttributes to corresponding ckw::BinaryOp");
    }
}

References ElementwiseBinaryCommonAttributes::Add, ARM_COMPUTE_ERROR, ElementwiseBinaryCommonAttributes::Div, ElementwiseBinaryCommonAttributes::Max, ElementwiseBinaryCommonAttributes::Min, ElementwiseBinaryCommonAttributes::Mul, ElementwiseBinaryCommonAttributes::operation(), ElementwiseBinaryCommonAttributes::Power, ElementwiseBinaryCommonAttributes::Prelu, ElementwiseBinaryCommonAttributes::SquaredDiff, and ElementwiseBinaryCommonAttributes::Sub.

to_ckw() [2/6]

ckw::TensorInfo arm_compute::experimental::dynamic_fusion::to_ckw ( const ITensorInfo &  tensor_info )

inline

Definition at line 88 of file Common.h.

{
    return ckw::TensorInfo{to_ckw(tensor_info.data_type()), to_ckw(tensor_info.tensor_shape()),
                           to_ckw(tensor_info.data_layout()), tensor_info.id()};
}

References tensor_info, and to_ckw().

to_ckw() [3/6]

ckw::TensorShape arm_compute::experimental::dynamic_fusion::to_ckw ( const TensorShape &  shape )

inline

NOTE: Overflow danger. Use size_t?

Definition at line 67 of file Common.h.

{
    ARM_COMPUTE_ERROR_ON(shape.num_max_dimensions < std::tuple_size<ckw::TensorShape>{});
    ARM_COMPUTE_ERROR_ON(std::tuple_size<ckw::TensorShape>{} != 5);
    /// NOTE: Overflow danger. Use size_t?
    return ckw::TensorShape{static_cast<int32_t>(shape[0]), static_cast<int32_t>(shape[1]),
                            static_cast<int32_t>(shape[2]), static_cast<int32_t>(shape[3]),
                            static_cast<int32_t>(shape[4])};
}

References ARM_COMPUTE_ERROR_ON, and arm_compute::test::validation::shape.

to_ckw() [4/6]

ckw::TensorStorageType arm_compute::experimental::dynamic_fusion::to_ckw ( const TensorStorageType &  storage )

inline

Definition at line 134 of file Common.h.

{
    switch (storage)
    {
        case TensorStorageType::ClBufferUint8Ptr:
            return ckw::TensorStorageType::BufferUint8Ptr;
        case TensorStorageType::ClImage2dReadOnly:
            return ckw::TensorStorageType::Texture2dReadOnly;
        case TensorStorageType::ClImage2dWriteOnly:
            return ckw::TensorStorageType::Texture2dWriteOnly;
        case TensorStorageType::Unknown:
            return ckw::TensorStorageType::Unknown;
        default:
            ARM_COMPUTE_ERROR("Unknown tensor storage type");
            return ckw::TensorStorageType::Unknown;
    }
}

References ARM_COMPUTE_ERROR.

to_ckw() [5/6]

ckw::TensorDataLayout arm_compute::experimental::dynamic_fusion::to_ckw ( DataLayout  dl )

inline

Definition at line 76 of file Common.h.

{
    switch (dl)
    {
        case DataLayout::NHWC:
            return ckw::TensorDataLayout::Nhwc;
        case DataLayout::NDHWC:
            return ckw::TensorDataLayout::Ndhwc;
        default:
            return ckw::TensorDataLayout::Unknown;
    }
}

References dl, arm_compute::NDHWC, and arm_compute::NHWC.

to_ckw() [6/6]

ckw::DataType arm_compute::experimental::dynamic_fusion::to_ckw ( DataType  dt )

inline

Definition at line 40 of file Common.h.

{
    switch (dt)
    {
        case DataType::F32:
            return ckw::DataType::Fp32;
        case DataType::F16:
            return ckw::DataType::Fp16;
        case DataType::S32:
            return ckw::DataType::Int32;
        case DataType::S16:
            return ckw::DataType::Int16;
        case DataType::S8:
        case DataType::QASYMM8_SIGNED:
            return ckw::DataType::Int8;
        case DataType::U32:
            return ckw::DataType::Uint32;
        case DataType::U16:
            return ckw::DataType::Uint16;
        case DataType::U8:
        case DataType::QASYMM8:
            return ckw::DataType::Uint8;
        default:
            return ckw::DataType::Unknown;
    }
}

References dt, arm_compute::F16, arm_compute::F32, arm_compute::QASYMM8, arm_compute::QASYMM8_SIGNED, arm_compute::S16, arm_compute::S32, arm_compute::S8, arm_compute::U16, arm_compute::U32, and arm_compute::U8.

Referenced by GpuCkwVariableTable::declare_variable(), to_ckw(), GpuCkwElementwiseBinary::write_component_code(), GpuCkwCast::write_component_code(), GpuCkwPool2d::write_component_code(), GpuCkwDepthwiseConv2d::write_component_code(), GpuCkwDirectConv2d::write_component_code(), and GpuCkwMatMul::write_component_code().

Variable Documentation

vector_size_byte_opencl

constexpr unsigned int vector_size_byte_opencl = 16

constexpr

Definition at line 41 of file ClTemplateElementwiseBinary.cpp.

Referenced by ClElementWiseUnaryKernel::configure(), CLRangeKernel::configure(), GpuCkwActivation::get_window(), GpuCkwElementwiseBinary::get_window(), GpuCkwCast::get_window(), and ClTemplateReshape::get_window().