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 Info for a WorkloadTensor of Auxiliary memory type. More...
struct	ClActivationKernelDescriptor
class	ClAuxTensorData
	Holder of any auxiliary CLTensors required by a ClWorkload. More...
struct	ClCodeBuilderContext
	All information required for building the ClKernelCode. More...
class	ClComponentDirectConv2d
class	ClComponentDirectConv2dSettings
	Component specific settings. More...
class	ClComponentStore
class	ClCompositeKernel
class	ClCompositeOperator
	Operator runtime to run a ClWorkload. More...
struct	ClDirectConv2dKernel
struct	ClDirectConv2dKernelDescriptor
class	ClDirectConvolutionKernelComponent
struct	ClElementwiseKernel
class	ClElementwiseKernelComponent
struct	ClElementwiseKernelDescriptor
struct	ClExecutionDescriptor
	Descriptor containing information required to run a single ClWorkload. More...
struct	ClFloorKernel
class	ClFloorKernelComponent
struct	ClFloorKernelDescriptor
struct	ClFusedKernelGraph
struct	ClKernel
struct	ClKernelArgDescriptor
	Describes all the info required to add a kernel argument at run time. More...
class	ClKernelBlueprint
	Intermediate representation of the final, complete kernel source. More...
struct	ClKernelCode
	Contains kernel code to be compiled and run in a ClUnitWorkload. More...
struct	ClKernelConfig
	Configurations for ClKernel. More...
struct	ClKernelFusionGroup
	A const view of a subgraph of the ClKernelGraph to be fused together. More...
struct	ClKernelGraph
class	ClKernelRuntime
	OpenCL runtime to run a single kernel. More...
struct	ClKernelTensor
class	ClStoreBlockBoundaryAwareKernelComponent
class	ClStoreIndirectWidthSelectKernelComponent
class	ClTemplateDirectConv2d
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...
struct	ClUnitWorkload
	The basic atomic unit in a ClWorkload. More...
struct	ClWorkload
	Workload for Cl backend. More...
struct	ClWorkloadContext
	Context (device capabilities, platform details) associated with a ClWorkload. More...
class	ClWorkloadRuntime
	OpenCL runtime to run a workload. More...
struct	ClWorkloadTensor
	A descriptor of ClWorkload Tensors. More...
class	Conv2dAttributes
	Attributes are backend-agnostic parameters (in addition to the input/output tensors) of an operator. More...
struct	Conv2dContent
struct	Conv2dDescriptor
	Descriptor for Conv2dDescriptor operation. More...
class	DependencyGraph
	The dependency graph of a workload, where the nodes are of 2 types: Tensor or Operator Represented as a doubly-linked adjacency list with the differentiation between source and destination. More...
class	ElementwiseContent
struct	ElementwiseDescriptor
	Descriptor for Elementwise binary operation. More...
class	FloorContent
struct	FloorDescriptor
	Descriptor for Floor operation. More...
class	GpuComponentServices
	Services that are used throughout the creation phase of workload code. More...
class	GpuConv2d
	Operator interface. More...
struct	GpuInfo
	GPU information for ClWorkloadContext. 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 Since fusion is restricted to a linear sequence of components in a kernel, only a single "intermediate variable" (the accumulator) is allowed. 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	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	GpuUnitWorkload
	The atomic unit in a Gpu workload. More...
class	GpuWorkloadArgument
	Describes all the info related to a kernel 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	IClKernelComponent
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	ITensorDescPack
struct	IWorkload
	Run-time-agnostic, platform-specific graph that describes everything required to run a workload It can be configured into an Arm Compute Library runtime, integrated into the runtime of another framework, or integrated into the compilation flow. More...
class	KernelProperties
	Properties common to all kernel component types. More...
struct	MemoryDescriptor
	Descriptor of a workload tensor memory. More...
class	Operator
	Operator Handle This can be used to further modify an existing operator. More...
struct	OperatorContent
class	OperatorGraph
	Graph of operators to execute within a Workload. More...
class	OpTensor
	Operator Tensor Handle This can be either an argument tensor, or an intermediate tensor linking 2 Operator s. More...
struct	OpTensorContent
struct	SharedVarLink
	Specifies a shared variable link for a component. More...
class	SharedVarTable
	A table of all the variables used in the kernel / blueprint Because we limit the DependencyGraph in the blueprint to a Linear Sequence for now, we only allow ** a single global variable (the accumulator) **. More...
struct	TagVal
	A tag value will substitute a tag in a string template during its instantiation. More...
class	TensorPackMap
	Map a kernel (as identified by its unit workload id) to its corresponding tensor pack. More...
struct	TileDescriptor
	Component: Store. More...
struct	UnitWorkload
	The basic atomic unit in an IWorkload. More...
struct	UnitWorkloadStage
	Describes when a Unit Workload is run. More...
struct	WorkloadTensor
	A descriptor for IWorkload Tensors. More...

Typedefs
using	ClKernelArgList = std::map< int, ClKernelArgDescriptor >
using	AuxMemoryLifetime = MemoryLifetime
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	OpTensorBinding = std::map< OpTensor, ITensor * >
	Map OpTensor handles to their corresponding ITensor memory. More...
using	ArgumentID = DependencyGraph::Id
using	ComponentID = DependencyGraph::Id
using	ComponentList = std::vector< ComponentID >
using	ComponentUniquePtr = std::unique_ptr< IClKernelComponent >
using	Id = DependencyGraph::Id
using	Settings = ClComponentDirectConv2dSettings
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	ClKernelTensorArgType : int {   Scalar, Vector, Image, Image_Reinterpret_As_3D,   Image_Export_To_ClImage2D, Image_3D, Image_3D_Export_To_ClImage2D, Tensor_3D,   Tensor_4D, Tensor_4D_t_Buffer, Tensor_4D_t_Image }
	Verbose and explicit way to enumerate all the tensor arguments variants used by all kernel implementations. More...
enum	MemoryType { Core = 0, Auxiliary = 1, User = 0, Auxiliary = 1 }
	Type of memory used by a Workload Tensor. More...
enum	GpuLanguage { OpenCL, Unknown }
	Gpu Language. More...
enum	MemoryType { Core = 0, Auxiliary = 1, User = 0, Auxiliary = 1 }
	Type of memory used by a workload tensor. More...
enum	SharedVarIO { Input, Output }
	We introduce the concept of Shared Variables in the context of kernel building. More...
enum	SharedVarGroup { Argument, Automatic }
enum	ComponentType { Simple, Complex, Store }
enum	ClippingStrategy { TOP_LEFT, TOP_RIGHT, BOTTOM_LEFT, BOTTOM_RIGHT }
enum	StoreType {   VStore, VStorePartial, StoreRow, ConvertStoreRow,   StoreBlock, ConvertStoreBlock, StoreRowPartial, StoreBlockPartial,   StoreBlockBoundaryAware, StoreVectorSelect, TStoreIndirectWidthSelect }
enum	Complexity { Simple, Complex }
enum	OperatorComplexity { Complex = 0, Simple }
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
Status	build (ClWorkload &workload, const OperatorGraph &op_graph, const ClWorkloadContext &ctx)
	Build a ClWorkload from an OperatorGraph. More...
template<typename T >
bool	is_in (const T &v, const std::vector< T > &vec)
Status	validate (const OperatorGraph &op_graph)
	Return the validity of op_graph, usually after performing an operation (e.g. More...
bool	operator< (const OpTensor &t0, const OpTensor &t1)
	Provide order of OpTensor by checking if t0 is "lower than" t1. More...
OpTensor	add_tensor (OperatorGraph &graph, ITensorInfo &info)
	Associate a TensorInfo with a newly created OpTensor in the graph. More...
bool	operator< (const Operator &op0, const Operator &op1)
	Provide order of Operator by checking if op0 is "lower than" op1. More...
Operator	add_op_conv2d (OperatorGraph &graph, const Conv2dDescriptor &desc, OpTensor input, OpTensor weights, OpTensor bias, OpTensor dst)
	Add op Conv2d to graph. More...
Operator	add_op_conv2d (OperatorGraph &graph, const Conv2dDescriptor &desc, OpTensor input, OpTensor weights, OpTensor dst)
void	force_conv2d_method (OperatorGraph &graph, Operator conv2d, ConvolutionMethod method)
	(Only for Debuging and Testing) Force a conv2d method More...
Operator	add_op_elementwise_op (OperatorGraph &graph, const ElementwiseDescriptor &desc, OpTensor lhs, OpTensor rhs, OpTensor dst)
	Add op Elementwise to graph, and optionally describes fusion through passing of intermediate OpTensor s. More...
Operator	add_op_floor (OperatorGraph &graph, const FloorDescriptor &desc, OpTensor src, OpTensor dst)
	Add op Floor to graph, and optionally describes fusion through passing of intermediate OpTensor s. More...
bool	operator== (const OpTensor &t0, const OpTensor &t1)
bool	operator== (const Conv2dDescriptor &conv2d0, const Conv2dDescriptor &conv2d1)
bool	operator== (const ElementwiseDescriptor &, const ElementwiseDescriptor &)
bool	operator== (const FloorDescriptor &, const FloorDescriptor &)
Status	bind_tensors (ClAuxTensorData &aux_tensor_data, TensorPackMap &prepare_pack_map, TensorPackMap &run_pack_map, const ClWorkload &workload, const OpTensorBinding &op_tensors)
	Bind tensor memory to packs used by prepare and run methods. More...
Status	add_tensor (ClKernelBlueprint &kernel_blueprint, ITensorInfo *tensor_info, ArgumentID &id, ArgumentID merge_point)
Status	add_kcomp_eltwise_op (ClKernelBlueprint &, const ClElementwiseKernelDescriptor &, ArgumentID src0_id, ArgumentID src1_id, ArgumentID &dst_id)
	Component: Eltwise Operator. More...
Status	add_kcomp_floor (ClKernelBlueprint &, const ClFloorKernelDescriptor &, ArgumentID src_id, ArgumentID &dst_id)
	Component: Floor. More...
Status	add_kcomp_activation (ClKernelBlueprint &, const ClActivationKernelDescriptor &, ArgumentID src_id, ArgumentID &dst_id)
	Component: Activation. More...
Status	add_kcomp_direct_conv2d (ClKernelBlueprint &, const ClDirectConv2dKernelDescriptor &, ArgumentID src_id, ArgumentID weight_id, ArgumentID bias_id, ArgumentID &dst_id)
	Component: Direct Convolution. More...
Status	add_kcomp_store (ClKernelBlueprint &kernel_blueprint, const StoreType &store_type, ArgumentID src_tile, ArgumentID dst_tile)
Status	update_merge_point (ClKernelBlueprint &, ArgumentID t_id, ArgumentID merge_point)
	Update existing merge tensor merge_point to point to t_id. More...
Status	set_tile_info (ClKernelBlueprint &bp, const TileDescriptor &tile_info)
Status	build (ClKernelCode &code, const ClCodeBuilderContext &, ClKernelBlueprint &)
	Build final kernel source from KernelBlueprint. More...
DependencyGraph	get_dependency_graph (const ClKernelBlueprint &blueprint)
	Get dependency graph. More...
Status	tune_static (ClExecutionDescriptor &, const ClKernelCode &)
bool	export_to_cl_image_support (const ITensorInfo *tensor, GPUTarget gpu_target, DataLayout data_layout)
inline ::std::ostream &	operator<< (::std::ostream &os, const CLBuildOptions::StringSet &build_opts)
inline ::std::ostream &	operator<< (::std::ostream &os, const CLBuildOptions &cl_build_opts)
std::string	to_string (const CLBuildOptions &cl_build_opts)
inline ::std::ostream &	operator<< (::std::ostream &os, const ClKernelCode &code)
std::string	to_string (const ClKernelCode &code)
std::vector< const ClKernel * >	traverse (const ClKernelFusionGroup &group)
std::vector< const ClKernelFusionGroup * >	traverse (const ClFusedKernelGraph &graph)
std::vector< ClKernelFusionGroup * >	traverse (ClFusedKernelGraph &graph)
std::pair< Status, ClFusedKernelGraph >	init_fusion_graph (const ClKernelGraph &kernel_graph)
Status	fuse (ClFusedKernelGraph &fused_kernel_graph)
Status	generate_store (ClKernelBlueprint &bp, const ClFusedKernelGraph &fused_kernel_graph, const ClKernelFusionGroup &fg)
Status	generate (ClWorkload &workload, const ClWorkloadContext &ctx, const ClFusedKernelGraph &fused_kernel_graph)
std::vector< const ClKernel * >	traverse (const ClKernelGraph &graph)
std::vector< ClKernel * >	traverse (ClKernelGraph &graph)
std::vector< const OperatorContent * >	traverse (const OperatorGraph::Implementation &graph)
std::vector< OperatorContent * >	traverse (OperatorGraph::Implementation &graph)
Status	translate (ClKernelGraph &kernel_graph, const OperatorGraph::Implementation &op_graph)
bool	operator== (const KernelProperties &config0, const KernelProperties &config1)
bool	operator== (const GpuKernelArgumentInfo &info0, const GpuKernelArgumentInfo &info1)
bool	operator== (const UnitWorkloadStage &stage0, const UnitWorkloadStage &stage1)

Typedef Documentation

ArgumentID

using ArgumentID = DependencyGraph::Id

Definition at line 41 of file ClKernelBuildingAPI.h.

AuxMemoryLifetime

using AuxMemoryLifetime = MemoryLifetime

Definition at line 65 of file IWorkload.h.

ClKernelArgList

using ClKernelArgList = std::map<int, ClKernelArgDescriptor>

Definition at line 87 of file ClWorkload.h.

ComponentId

using ComponentId = int32_t

Uniquely identifies a kernel component within a workload.

Definition at line 37 of file Types.h.

ComponentID

using ComponentID = DependencyGraph::Id

Definition at line 254 of file Common.h.

ComponentList

using ComponentList = std::vector<ComponentID>

Definition at line 255 of file Common.h.

ComponentUniquePtr

using ComponentUniquePtr = std::unique_ptr<IClKernelComponent>

Definition at line 414 of file Common.h.

GpuKernelArgumentList

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

The argument list of a GpuKernelSourceCode.

Definition at line 41 of file GpuKernelSourceCode.h.

GpuTarget

using GpuTarget = ::arm_compute::GPUTarget

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

Definition at line 40 of file GpuWorkloadContext.h.

Id

using Id = DependencyGraph::Id

Definition at line 250 of file ClKernelGraph.h.

MemoryDescriptorMap

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

A map from ITensorInfo to their corresponding MemoryDescriptor.

Definition at line 71 of file MemoryDescriptor.h.

OperatorId

using OperatorId = DependencyGraph::OperatorId

Definition at line 39 of file GpuOperatorGroup.h.

OpTensorBinding

using OpTensorBinding = std::map<OpTensor, ITensor *>

Map OpTensor handles to their corresponding ITensor memory.

Definition at line 44 of file ClCompositeOperator.h.

Settings

using Settings = ClComponentDirectConv2dSettings

Definition at line 38 of file ClComponentDirectConv2d.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.

UnitWorkloadId

using UnitWorkloadId = int32_t

Uniquely identifies a GpuUnitWorkload within a GpuWorkloadSourceCode.

Definition at line 38 of file GpuWorkloadSourceCode.h.

Enumeration Type Documentation

ClippingStrategy

enum ClippingStrategy

strong

Enumerator
TOP_LEFT
TOP_RIGHT
BOTTOM_LEFT
BOTTOM_RIGHT

Definition at line 71 of file ClKernelDescriptors.h.

{
    TOP_LEFT,
    TOP_RIGHT,
    BOTTOM_LEFT,
    BOTTOM_RIGHT,
};

ClKernelTensorArgType

enum ClKernelTensorArgType : int

strong

Verbose and explicit way to enumerate all the tensor arguments variants used by all kernel implementations.

This avoids any ambiguity in what kernel arguments are passed

Enumerator
Scalar
Vector
Image
Image_Reinterpret_As_3D
Image_Export_To_ClImage2D
Image_3D
Image_3D_Export_To_ClImage2D
Tensor_3D
Tensor_4D
Tensor_4D_t_Buffer
Tensor_4D_t_Image

Definition at line 46 of file ClWorkload.h.

                                 : int
{
    Scalar,

    Vector,

    Image,
    Image_Reinterpret_As_3D,
    Image_Export_To_ClImage2D,

    Image_3D, // 3D Tensor represented as a 2D Image + stride_z
    Image_3D_Export_To_ClImage2D,

    Tensor_3D,
    Tensor_4D,
    Tensor_4D_t_Buffer,
    Tensor_4D_t_Image
};

Complexity

enum Complexity

strong

Enumerator
Simple
Complex

Definition at line 45 of file ClKernelGraph.h.

{
    Simple,
    Complex
};

ComponentType

enum ComponentType

strong

Enumerator
Simple
Complex
Store

Definition at line 247 of file Common.h.

{
    Simple,
    Complex,
    Store
};

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 43 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 [1/2]

enum MemoryType

strong

Type of memory used by a workload tensor.

Enumerator
Core	Core memory used by the Workload Tensor, e.g. for argument tensors
Auxiliary	Auxiliary memory required by the Workload Tensor, e.g. for temporary tensors
User	Memory coming directly from users, e.g. for argument tensors
Auxiliary	Additional memory required by the workload tensor, e.g. for temporary tensors

Definition at line 36 of file MemoryDescriptor.h.

{
    User      = 0, /**< Memory coming directly from users, e.g. for argument tensors */
    Auxiliary = 1, /**< Additional memory required by the workload tensor, e.g. for temporary tensors */
};

MemoryType [2/2]

enum MemoryType

strong

Type of memory used by a Workload Tensor.

Enumerator
Core	Core memory used by the Workload Tensor, e.g. for argument tensors
Auxiliary	Auxiliary memory required by the Workload Tensor, e.g. for temporary tensors
User	Memory coming directly from users, e.g. for argument tensors
Auxiliary	Additional memory required by the workload tensor, e.g. for temporary tensors

Definition at line 59 of file IWorkload.h.

{
    Core      = 0, /**< Core memory used by the Workload Tensor, e.g. for argument tensors */
    Auxiliary = 1, /**< Auxiliary memory required by the Workload Tensor, e.g. for temporary tensors */
};

OperatorComplexity

enum OperatorComplexity

strong

Enumerator
Complex
Simple

Definition at line 44 of file OperatorGraphImpl.h.

{
    Complex = 0,
    Simple
};

SharedVarGroup

enum SharedVarGroup

strong

Enumerator
Argument
Automatic

Definition at line 65 of file Common.h.

{
    Argument, // Parameters to a kernel function  == dst or src tensors of the whole blueprint graph
    Automatic // Automatic variables declared within the kernel body == intermediate tensors of the whole blueprint graph
};

SharedVarIO

enum SharedVarIO

strong

We introduce the concept of Shared Variables in the context of kernel building.

They are variables that can be accessed / shared among all the kernel components within a single kernel. For now we consider 2 groups of shared variables: Argument: The argument variables (parameters) of a kernel Automatic: The automatic variables declared inside a kernel All Shared Variables have the same kernel scope, and are thus visible to all kernel components

Enumerator
Input
Output

Definition at line 59 of file Common.h.

{
    Input,
    Output
};

StoreType

enum StoreType

strong

Enumerator
VStore
VStorePartial
StoreRow
ConvertStoreRow
StoreBlock
ConvertStoreBlock
StoreRowPartial
StoreBlockPartial
StoreBlockBoundaryAware
StoreVectorSelect
TStoreIndirectWidthSelect

Definition at line 103 of file ClKernelDescriptors.h.

{
    VStore,
    VStorePartial,
    StoreRow,
    ConvertStoreRow,
    StoreBlock,
    ConvertStoreBlock,
    StoreRowPartial,
    StoreBlockPartial,
    StoreBlockBoundaryAware,
    StoreVectorSelect,
    TStoreIndirectWidthSelect
};

Function Documentation

add_kcomp_activation()

Status add_kcomp_activation	(	ClKernelBlueprint &	,
		const ClActivationKernelDescriptor &	,
		ArgumentID	,
		ArgumentID &
	)

Component: Activation.

Definition at line 84 of file ClKernelBuildingAPI.cpp.

{
    return Status{};
}

add_kcomp_direct_conv2d()

Status add_kcomp_direct_conv2d	(	ClKernelBlueprint &	kernel_blueprint,
		const ClDirectConv2dKernelDescriptor &	direct_conv2d_desc,
		ArgumentID	src_id,
		ArgumentID	weight_id,
		ArgumentID	bias_id,
		ArgumentID &	dst_id
	)

Component: Direct Convolution.

Definition at line 89 of file ClKernelBuildingAPI.cpp.

References ClKernelBlueprint::Implementation::add_component(), ClKernelBlueprint::impl(), Input, and Output.

Referenced by ClDirectConv2dKernel::generate().

{
    kernel_blueprint.impl().add_component(
        std::make_unique<ClDirectConvolutionKernelComponent>(
            &kernel_blueprint,
            direct_conv2d_desc,
            SharedVarLink{ src_id, SharedVarIO::Input },
            SharedVarLink{ weight_id, SharedVarIO::Input },
            SharedVarLink{ dst_id, SharedVarIO::Output },
            SharedVarLink{ bias_id, SharedVarIO::Input }));

    return Status{};
}

add_kcomp_eltwise_op()

Status add_kcomp_eltwise_op	(	ClKernelBlueprint &	kernel_blueprint,
		const ClElementwiseKernelDescriptor &	desc,
		ArgumentID	src0_id,
		ArgumentID	src1_id,
		ArgumentID &	dst_id
	)

Component: Eltwise Operator.

Definition at line 58 of file ClKernelBuildingAPI.cpp.

References ClKernelBlueprint::Implementation::add_component(), ClKernelBlueprint::impl(), Input, and Output.

Referenced by ClElementwiseKernel::generate().

{
    kernel_blueprint.impl().add_component(
        std::make_unique<ClElementwiseKernelComponent>(
            &kernel_blueprint,
            desc,
            SharedVarLink{ src0_id, SharedVarIO::Input },
            SharedVarLink{ src1_id, SharedVarIO::Input },
            SharedVarLink{ dst_id, SharedVarIO::Output }));

    return Status{};
}

add_kcomp_floor()

Status add_kcomp_floor	(	ClKernelBlueprint &	kernel_blueprint,
		const ClFloorKernelDescriptor &	,
		ArgumentID	src_id,
		ArgumentID &	dst_id
	)

Component: Floor.

Definition at line 72 of file ClKernelBuildingAPI.cpp.

References ClKernelBlueprint::Implementation::add_component(), ClKernelBlueprint::impl(), Input, and Output.

Referenced by ClFloorKernel::generate().

{
    kernel_blueprint.impl().add_component(
        std::make_unique<ClFloorKernelComponent>(
            &kernel_blueprint,
            SharedVarLink{ src_id, SharedVarIO::Input },
            SharedVarLink{ dst_id, SharedVarIO::Output }));

    return Status{};
}

add_kcomp_store()

Status add_kcomp_store	(	ClKernelBlueprint &	kernel_blueprint,
		const StoreType &	store_type,
		ArgumentID	src_tile,
		ArgumentID	dst_tile
	)

Definition at line 105 of file ClKernelBuildingAPI.cpp.

References ClKernelBlueprint::Implementation::add_component(), ARM_COMPUTE_ERROR, ClKernelBlueprint::impl(), Input, Output, StoreBlockBoundaryAware, and TStoreIndirectWidthSelect.

Referenced by generate_store().

{
    switch(store_type)
    {
        case StoreType::StoreBlockBoundaryAware:
            kernel_blueprint.impl().add_component(
                std::make_unique<ClStoreBlockBoundaryAwareKernelComponent>(
                    &kernel_blueprint,
                    SharedVarLink{ src_tile, SharedVarIO::Input },
                    SharedVarLink{ dst_tile, SharedVarIO::Output }));
            break;
        case StoreType::TStoreIndirectWidthSelect:
            kernel_blueprint.impl().add_component(
                std::make_unique<ClStoreIndirectWidthSelectKernelComponent>(
                    &kernel_blueprint,
                    SharedVarLink{ src_tile, SharedVarIO::Input },
                    SharedVarLink{ dst_tile, SharedVarIO::Output }));
            break;
        default:
            ARM_COMPUTE_ERROR("Store mode not yet supported.");
    }

    return Status{};
}

add_op_conv2d() [1/2]

Operator add_op_conv2d	(	OperatorGraph &	graph,
		const Conv2dDescriptor &	desc,
		OpTensor	input,
		OpTensor	weights,
		OpTensor	bias,
		OpTensor	dst
	)

Add op Conv2d to graph.

Parameters

[in,out]	graph	OperatorGraph where the operator is added to
[in]	desc	Operator descriptor
[in]	input	Input OpTensor
[in]	weights	Weights OpTensor
[in]	bias	(Optional) bias OpTensor
[in]	dst	Destination OpTensor

Returns

Operator

Examples:

dynamic_fusion/cl_fused_conv2d_elementwise_add.cpp.

Definition at line 134 of file OperatorGraph.cpp.

References arm_compute::ACL_DST_0, arm_compute::ACL_SRC_0, arm_compute::ACL_SRC_1, arm_compute::ACL_SRC_2, ITensorDescPack< TDesc >::add_const_tensor(), OperatorGraph::Implementation::add_node(), DependencyGraph::add_operator(), arm_compute::auto_init_if_empty(), Padding2D::bottom, arm_compute::misc::shape_calculator::compute_deep_convolution_shape(), arm_compute::FLOOR, DependencyGraph::get_root_ops(), OpTensorContent::get_tensor_info(), OperatorGraph::Implementation::graph, OpTensor::id(), OperatorGraph::impl(), Padding2D::left, Conv2dDescriptor::pad, Padding2D::right, arm_compute::RUNTIME_ERROR, arm_compute::test::validation::shape, arm_compute::test::validation::src, OperatorGraph::Implementation::status, Conv2dDescriptor::stride, OperatorGraph::Implementation::tensors, Padding2D::top, ITensorInfo::total_size(), Size2D::x(), and Size2D::y().

Referenced by add_op_conv2d(), and arm_compute::test::validation::TEST_CASE().

{
    // Check if map is empty as a complex operator can only be root
    if(!graph.impl()->graph.get_root_ops().empty())
    {
        graph.impl()->status = Status{ ErrorCode::RUNTIME_ERROR, "Cannot add multiple complex operators" };
        return Operator{};
    }

    std::pair<Status, DependencyGraph::Id> status_id;

    if(bias.id() == -1)
    {
        status_id = graph.impl()->graph.add_operator({ input.id(), weights.id() }, { dst.id() });
    }
    else
    {
        status_id = graph.impl()->graph.add_operator({ input.id(), weights.id(), bias.id() }, { dst.id() });
    }

    check_dependency_graph_op_success(graph, status_id.first);

    Operator op_node(status_id.second);

    // Infer TensorInfo
    OpTensorContent *dst_tensor = graph.impl()->tensors[dst.id()].get();
    if(dst_tensor->get_tensor_info()->total_size() == 0)
    {
        auto src   = graph.impl()->tensors[input.id()]->get_tensor_info();
        auto wts   = graph.impl()->tensors[weights.id()]->get_tensor_info();
        auto shape = misc::shape_calculator::compute_deep_convolution_shape(src->tensor_shape(), src->data_layout(), wts->tensor_shape(), PadStrideInfo(desc.stride.x(), desc.stride.y(), desc.pad.left,
                                                                            desc.pad.right,
                                                                            desc.pad.top, desc.pad.bottom, DimensionRoundingType::FLOOR)); // use the default DimensionRoundingType

        auto_init_if_empty(*(dst_tensor->get_tensor_info()), src->clone()->set_tensor_shape(shape));
    }

    // Check execution space
    auto dst_info = dst_tensor->get_tensor_info();
    check_execution_shape(graph, *dst_info);

    ITensorDescPack<OpTensorContent> tensors;
    tensors.add_const_tensor(ACL_SRC_0, graph.impl()->tensors[input.id()].get());
    tensors.add_const_tensor(ACL_SRC_1, graph.impl()->tensors[weights.id()].get());
    if(bias.id() != -1)
    {
        tensors.add_const_tensor(ACL_SRC_2, graph.impl()->tensors[bias.id()].get());
    }
    tensors.add_const_tensor(ACL_DST_0, graph.impl()->tensors[dst.id()].get());

    graph.impl()->add_node<Conv2dContent>(status_id.second, desc, tensors);
    check_multiple_roots(graph);

    return op_node;
}

add_op_conv2d() [2/2]

Operator add_op_conv2d	(	OperatorGraph &	graph,
		const Conv2dDescriptor &	desc,
		OpTensor	input,
		OpTensor	weights,
		OpTensor	dst
	)

Definition at line 190 of file OperatorGraph.cpp.

References add_op_conv2d().

{
    return add_op_conv2d(graph, desc, input, weights, OpTensor(-1), dst);
}

add_op_elementwise_op()

Operator add_op_elementwise_op	(	OperatorGraph &	graph,
		const ElementwiseDescriptor &	desc,
		OpTensor	lhs,
		OpTensor	rhs,
		OpTensor	dst
	)

Add op Elementwise to graph, and optionally describes fusion through passing of intermediate OpTensor s.

Parameters

[in,out]	graph	OperatorGraph where the operator is added to
[in]	desc	Operator descriptor
[in]	lhs	Lhs OpTensor
[in]	rhs	Rhs OpTensor
[in]	dst	Destination OpTensor

Returns

Operator

Examples:

dynamic_fusion/cl_fused_conv2d_elementwise_add.cpp.

Definition at line 201 of file OperatorGraph.cpp.

References arm_compute::ACL_DST_0, arm_compute::ACL_SRC_0, arm_compute::ACL_SRC_1, ITensorDescPack< TDesc >::add_const_tensor(), OperatorGraph::Implementation::add_node(), DependencyGraph::add_operator(), arm_compute::auto_init_if_empty(), ITensorInfo::broadcast_shape_and_valid_region(), OpTensorContent::get_tensor_info(), OperatorGraph::Implementation::graph, OpTensor::id(), OperatorGraph::impl(), OperatorGraph::Implementation::tensors, and ITensorInfo::total_size().

Referenced by arm_compute::test::validation::TEST_CASE().

{
    auto id = graph.impl()->graph.add_operator({ rhs.id(), lhs.id() }, { dst.id() });
    check_dependency_graph_op_success(graph, id.first);

    Operator op_node(id.second);

    // Infer TensorInfo
    auto             node_lhs = graph.impl()->tensors[lhs.id()]->get_tensor_info();
    auto             node_rhs = graph.impl()->tensors[rhs.id()]->get_tensor_info();
    OpTensorContent *node_dst = graph.impl()->tensors[dst.id()].get();

    if(node_dst->get_tensor_info()->total_size() == 0)
    {
        const std::pair<TensorShape, ValidRegion> broadcast_pair = ITensorInfo::broadcast_shape_and_valid_region(*node_rhs, *node_lhs);
        auto_init_if_empty(*(node_dst->get_tensor_info()), node_lhs->clone()->set_tensor_shape(broadcast_pair.first));
    }

    // Check execution space
    auto dst_info = node_dst->get_tensor_info();
    check_execution_shape(graph, *dst_info);

    ITensorDescPack<OpTensorContent> tensors;
    tensors.add_const_tensor(ACL_SRC_0, graph.impl()->tensors[lhs.id()].get());
    tensors.add_const_tensor(ACL_SRC_1, graph.impl()->tensors[rhs.id()].get());
    tensors.add_const_tensor(ACL_DST_0, graph.impl()->tensors[dst.id()].get());
    graph.impl()->add_node<ElementwiseContent>(id.second, desc, tensors);
    check_multiple_roots(graph);

    return op_node;
}

add_op_floor()

Operator add_op_floor	(	OperatorGraph &	graph,
		const FloorDescriptor &	desc,
		OpTensor	src,
		OpTensor	dst
	)

Add op Floor to graph, and optionally describes fusion through passing of intermediate OpTensor s.

Parameters

[in,out]	graph	OperatorGraph where the operator is added to
[in]	desc	Operator descriptor
[in]	src	Source OpTensor
[in]	dst	Destination OpTensor

Returns

Operator

Definition at line 233 of file OperatorGraph.cpp.

References arm_compute::ACL_DST_0, arm_compute::ACL_SRC_0, ITensorDescPack< TDesc >::add_const_tensor(), OperatorGraph::Implementation::add_node(), DependencyGraph::add_operator(), arm_compute::auto_init_if_empty(), OpTensorContent::get_tensor_info(), OperatorGraph::Implementation::graph, OpTensor::id(), OperatorGraph::impl(), OperatorGraph::Implementation::tensors, and ITensorInfo::total_size().

Referenced by arm_compute::test::validation::TEST_CASE().

{
    auto id = graph.impl()->graph.add_operator({ src.id() }, { dst.id() });
    check_dependency_graph_op_success(graph, id.first);

    Operator op_node(id.second);

    // Infer TensorInfo
    auto             node_src = graph.impl()->tensors[src.id()]->get_tensor_info();
    OpTensorContent *node_dst = graph.impl()->tensors[dst.id()].get();

    if(node_dst->get_tensor_info()->total_size() == 0)
    {
        auto_init_if_empty(*(node_dst->get_tensor_info()), *node_src);
    }

    // Check execution space
    auto dst_info = node_dst->get_tensor_info();
    check_execution_shape(graph, *dst_info);

    ITensorDescPack<OpTensorContent> tensors;
    tensors.add_const_tensor(ACL_SRC_0, graph.impl()->tensors[src.id()].get());
    tensors.add_const_tensor(ACL_DST_0, graph.impl()->tensors[dst.id()].get());
    graph.impl()->add_node<FloorContent>(id.second, desc, tensors);
    check_multiple_roots(graph);

    return op_node;
}

add_tensor() [1/2]

Status add_tensor	(	ClKernelBlueprint &	kernel_blueprint,
		ITensorInfo *	tensor_info,
		ArgumentID &	id,
		ArgumentID	merge_point
	)

Definition at line 52 of file ClKernelBuildingAPI.cpp.

References ClKernelBlueprint::Implementation::add_kernel_tensor(), and ClKernelBlueprint::impl().

{
    id = kernel_blueprint.impl().add_kernel_tensor(tensor_info, merge_point);
    return Status{};
}

add_tensor() [2/2]

OpTensor add_tensor	(	OperatorGraph &	graph,
		ITensorInfo &	info
	)

Associate a TensorInfo with a newly created OpTensor in the graph.

Note

info needs to remain in scope and valid until the workload has finished building

Can pass in an empty TensorInfo for a destination Tensor, in which case info will be inferred from the source tensors

Parameters

[in,out]	graph	OperatorGraph where the tensor is added
[in]	info	TensorInfo to be associated

Returns

OpTensor

Examples:

dynamic_fusion/cl_fused_conv2d_elementwise_add.cpp.

Definition at line 126 of file OperatorGraph.cpp.

References DependencyGraph::add_tensor(), OperatorGraph::Implementation::add_tensor(), OperatorGraph::Implementation::graph, and OperatorGraph::impl().

Referenced by ClDirectConv2dKernel::generate(), ClElementwiseKernel::generate(), ClFloorKernel::generate(), generate_store(), and arm_compute::test::validation::TEST_CASE().

{
    auto     id = graph.impl()->graph.add_tensor();
    OpTensor op_tensor(id);
    graph.impl()->add_tensor(id, &info);
    return op_tensor;
}

bind_tensors()

Status bind_tensors	(	ClAuxTensorData &	aux_tensor_data,
		TensorPackMap &	prepare_pack_map,
		TensorPackMap &	run_pack_map,
		const ClWorkload &	workload,
		const OpTensorBinding &	op_tensors
	)

Bind tensor memory to packs used by prepare and run methods.

Create auxiliary tensor objects and their memory requirements if needed

Note

This is the only method for external user to create ClAuxTensorData, and the prepare and run TensorPackMaps

Parameters

[out]	aux_tensor_data	Auxiliary Tensors required by the workload
[out]	prepare_pack_map	TensorPackMap used by the prepare method
[out]	run_pack_map	TensorPackMap used by the run method
[in]	workload	ClWorkload to bind the tensors to
[in]	op_tensors	CLTensor memory objects mapped from Core OpTensors

Returns

Status

Examples:

dynamic_fusion/cl_fused_conv2d_elementwise_add.cpp.

Definition at line 104 of file ClCompositeOperator.cpp.

References ClAuxTensorData::add_aux_tensor(), ARM_COMPUTE_CREATE_ERROR, ARM_COMPUTE_RETURN_ON_ERROR, Auxiliary, Core, memory_info, ClWorkload::op_tensor_id_lut, arm_compute::RUNTIME_ERROR, tensor_info, and ClWorkload::tensors.

Referenced by arm_compute::test::validation::TEST_CASE().

{
    for(auto tensor : workload.tensors)
    {
        const auto wk_tensor_id  = tensor.first; // workload tensor id
        ICLTensor *tensor_object = nullptr;
        if(tensor.second.memory_type == MemoryType::Core)
        {
            const auto op_tensor_id   = workload.op_tensor_id_lut.at(wk_tensor_id);
            auto       op_tensor_find = op_tensors.find(op_tensor_id);
            if(op_tensor_find == op_tensors.end())
            {
                return ARM_COMPUTE_CREATE_ERROR(ErrorCode::RUNTIME_ERROR, "Cannot find binding for some operator tensor");
            }
            tensor_object = utils::cast::polymorphic_downcast<ICLTensor *>(op_tensor_find->second);
        }
        else if(tensor.second.memory_type == MemoryType::Auxiliary)
        {
            // Create aux tensor CLTensor object
            const TensorInfo tensor_info = *tensor.second.info;
            const auto       memory_info = tensor.second.memory_info;
            tensor_object                = aux_tensor_data.add_aux_tensor(wk_tensor_id, tensor_info, memory_info);
        }
        else
        {
            return ARM_COMPUTE_CREATE_ERROR(ErrorCode::RUNTIME_ERROR, "Unsupported tensor memory type");
        }

        const auto st = add_tensor_to_tensor_pack(wk_tensor_id, tensor_object, workload, prepare_pack_map, run_pack_map);
        ARM_COMPUTE_RETURN_ON_ERROR(st);
    }
    return Status{};
}

build() [1/2]

Status build	(	ClKernelCode &	code,
		const ClCodeBuilderContext &	,
		ClKernelBlueprint &	kernel_blueprint
	)

Build final kernel source from KernelBlueprint.

Definition at line 140 of file ClKernelBuildingAPI.cpp.

References ClKernelCode::arguments, ClKernelBlueprint::Implementation::build_code(), ClKernelBlueprint::Implementation::build_config_id(), ClKernelBlueprint::Implementation::build_kernel_name(), ClKernelCode::build_options, ClKernelBlueprint::Implementation::build_options(), ClKernelCode::code, ClKernelCode::config_id, ClKernelBlueprint::Implementation::finalize(), ClKernelBlueprint::Implementation::get_arguments(), ClKernelBlueprint::Implementation::get_execution_window(), ClKernelBlueprint::impl(), ClKernelCode::name, and ClKernelCode::window.

{
    kernel_blueprint.impl().finalize();
    code.name = kernel_blueprint.impl().build_kernel_name();
    code.code = kernel_blueprint.impl().build_code();

    code.config_id     = kernel_blueprint.impl().build_config_id();
    code.build_options = kernel_blueprint.impl().build_options();
    code.window        = kernel_blueprint.impl().get_execution_window();
    code.arguments     = kernel_blueprint.impl().get_arguments();

    return Status{};
}

build() [2/2]

Status build	(	ClWorkload &	workload,
		const OperatorGraph &	op_graph,
		const ClWorkloadContext &	ctx
	)

Build a ClWorkload from an OperatorGraph.

Parameters

[out]	workload
[in]	op_graph
[in]	ctx

Returns

Status

Examples:

dynamic_fusion/cl_fused_conv2d_elementwise_add.cpp.

Definition at line 36 of file ClWorkload.cpp.

References ARM_COMPUTE_RETURN_ON_ERROR, ClWorkload::context, DependencyGraph::dst_tensors(), fuse(), generate(), DependencyGraph::get_merge_points(), IWorkload::graph, OperatorGraph::Implementation::graph, ClKernelGraph::graph, OperatorGraph::impl(), init_fusion_graph(), ClWorkload::op_tensor_id_lut, ClFusedKernelGraph::original_graph, DependencyGraph::src_tensors(), ClWorkload::status, translate(), and validate().

Referenced by Program::binary(), generate(), and arm_compute::test::validation::TEST_CASE().

{
    workload.context = ctx;
    ClKernelGraph kernel_graph;
    workload.status = validate(op_graph);
    ARM_COMPUTE_RETURN_ON_ERROR(workload.status);
    workload.status = translate(kernel_graph, *op_graph.impl());
    ARM_COMPUTE_RETURN_ON_ERROR(workload.status);
    ClFusedKernelGraph fused_k_graph;
    std::tie(workload.status, fused_k_graph) = init_fusion_graph(kernel_graph);
    ARM_COMPUTE_RETURN_ON_ERROR(workload.status);
    workload.status = fuse(fused_k_graph);
    ARM_COMPUTE_RETURN_ON_ERROR(workload.status);
    workload.status = generate(workload, ctx, fused_k_graph);
    ARM_COMPUTE_RETURN_ON_ERROR(workload.status);

    // Get operator tensor id to workload tensor id map
    const auto op_tensor_to_kernel_tensor       = fused_k_graph.original_graph->graph.get_merge_points();
    const auto kernel_tensor_to_workload_tensor = workload.graph.get_merge_points();
    for(const auto op_t : op_graph.impl()->graph.src_tensors())
    {
        const auto kernel_t                   = op_tensor_to_kernel_tensor.at(op_t);
        const auto workload_t                 = kernel_tensor_to_workload_tensor.at(kernel_t);
        workload.op_tensor_id_lut[workload_t] = op_t;
    }
    for(const auto op_t : op_graph.impl()->graph.dst_tensors())
    {
        const auto kernel_t                   = op_tensor_to_kernel_tensor.at(op_t);
        const auto workload_t                 = kernel_tensor_to_workload_tensor.at(kernel_t);
        workload.op_tensor_id_lut[workload_t] = op_t;
    }
    return workload.status;
}

export_to_cl_image_support()

bool arm_compute::experimental::dynamic_fusion::export_to_cl_image_support	(	const ITensorInfo *	tensor,
		GPUTarget	gpu_target,
		DataLayout	data_layout
	)

Definition at line 251 of file ClDirectConvolutionKernelComponent.cpp.

References ITensorInfo::data_type(), arm_compute::G71, CLKernelLibrary::get(), arm_compute::get_arch_from_target(), arm_compute::get_cl_image_pitch_alignment(), CLKernelLibrary::get_device(), arm_compute::image2d_from_buffer_supported(), arm_compute::is_data_type_float(), arm_compute::MIDGARD, arm_compute::NHWC, and ITensorInfo::tensor_shape().

Referenced by ClDirectConvolutionKernelComponent::allocate_shared_vars(), GpuConv2d::create_op(), ClDirectConvolutionKernelComponent::generate_build_options(), and GpuConv2d::validate_op().

{
    if(tensor->tensor_shape()[0] % 4 || (data_layout != DataLayout::NHWC))
    {
        return false;
    }

    // If not floating point
    if(!is_data_type_float(tensor->data_type()))
    {
        return false;
    }

    if(gpu_target == GPUTarget::G71 || get_arch_from_target(gpu_target) == GPUTarget::MIDGARD)
    {
        return false;
    }

    // Check if the cl_khr_image2d_from_buffer extension is supported on the target platform
    if(!image2d_from_buffer_supported(CLKernelLibrary::get().get_device()))
    {
        return false;
    }

    // Check cl image pitch alignment
    if(get_cl_image_pitch_alignment(CLKernelLibrary::get().get_device()) == 0)
    {
        return false;
    }

    const size_t image_w     = tensor->tensor_shape()[0] / 4;
    const size_t image_h     = tensor->tensor_shape()[1] * tensor->tensor_shape()[2] * tensor->tensor_shape()[3];
    const size_t max_image_w = CLKernelLibrary::get().get_device().getInfo<CL_DEVICE_IMAGE2D_MAX_WIDTH>();
    const size_t max_image_h = CLKernelLibrary::get().get_device().getInfo<CL_DEVICE_IMAGE2D_MAX_HEIGHT>();

    if(image_w > max_image_w || image_h > max_image_h)
    {
        return false;
    }

    return true;
}

force_conv2d_method()

void force_conv2d_method	(	OperatorGraph &	graph,
		Operator	conv2d,
		ConvolutionMethod	method
	)

(Only for Debuging and Testing) Force a conv2d method

Parameters

[in,out]	graph	OperatorGraph where conv2d op is located
[in]	conv2d	Conv2d Op
[in]	method	Forced ConvolutionMethod

Examples:

dynamic_fusion/cl_fused_conv2d_elementwise_add.cpp.

Definition at line 195 of file OperatorGraph.cpp.

References Operator::id(), OperatorGraph::impl(), and OperatorGraph::Implementation::operators.

Referenced by arm_compute::test::validation::TEST_CASE().

{
    auto node = utils::cast::polymorphic_downcast<Conv2dContent *>(graph.impl()->operators[conv2d.id()].get());
    node->set_method(method);
}

fuse()

Status fuse

(

ClFusedKernelGraph &

fused_kernel_graph

)

Definition at line 96 of file ClFusedKernelGraph.cpp.

References ClFusedKernelGraph::can_fuse(), ClFusedKernelGraph::fuse(), and traverse().

Referenced by build().

{
    // A naive fusion algorithm that's guaranteed to find optimal pattern if there are no branches
    // If there are branches, the algorithm cannot guanrantee optimality as it doesn't perform any searches

    bool fusion_found = false;
    do
    {
        fusion_found          = false;
        const auto sorted_fgs = traverse(fused_kernel_graph);
        if(sorted_fgs.size() <= 1)
        {
            // Only one or zero fusion group, thus no need to perform fusion
            return Status{};
        }
        auto fgs_combo = get_combinations(sorted_fgs);
        for(auto fgs : fgs_combo)
        {
            auto       fg0 = fgs.first;
            auto       fg1 = fgs.second;
            const auto st  = fused_kernel_graph.can_fuse(*fg0, *fg1);
            if(bool(st))
            {
                const auto st = fused_kernel_graph.fuse(*fg0, *fg1);
                if(!bool(st))
                {
                    return st;
                }
                fusion_found = true;
                break;
            }
        }
    }
    while(fusion_found);
    return Status{};
}

generate()

Status generate	(	ClWorkload &	workload,
		const ClWorkloadContext &	ctx,
		const ClFusedKernelGraph &	fused_kernel_graph
	)

Definition at line 170 of file ClFusedKernelGraph.cpp.

References ClWorkload::add_unit_workload(), ClWorkload::add_workload_tensor(), build(), ClWorkload::context, DependencyGraph::dst_tensors(), ClFusedKernelGraph::fg_dependency, generate_store(), get_dependency_graph(), ClKernelGraph::get_tensor(), ClWorkloadContext::gpu_info, ClFusedKernelGraph::original_graph, set_tile_info(), DependencyGraph::src_tensors(), and traverse().

Referenced by build(), ClDirectConv2dKernel::ClDirectConv2dKernel(), ClElementwiseKernel::ClElementwiseKernel(), and ClFloorKernel::ClFloorKernel().

{
    workload.context = ctx;
    for(const auto &fg : traverse(fused_kernel_graph))
    {
        ClKernelBlueprint bp{};
        for(const auto &kernel : traverse(*fg))
        {
            const auto st = kernel->generate(bp);
            if(!bool(st))
            {
                return st;
            }
        }
        auto st = set_tile_info(bp, fg->get_root_kernel()->config().tile_desc);
        if(!bool(st))
        {
            return st;
        }
        st = generate_store(bp, fused_kernel_graph, *fg);
        if(!bool(st))
        {
            return st;
        }

        ClKernelCode code{};
        st = build(code, ClCodeBuilderContext{ ctx.gpu_info }, bp);
        if(!bool(st))
        {
            return st;
        }
        const auto bp_graph = get_dependency_graph(bp);

        // Get tensor info
        std::vector<Id> workload_src_tensors{};
        for(const auto &src_t_id : fused_kernel_graph.fg_dependency.src_tensors(fg->id))
        {
            const auto src_t = fused_kernel_graph.original_graph->get_tensor(src_t_id);
            // Get corresponding kernel arg descriptor
            const auto arg_desc    = code.arguments.at(bp_graph.get_merge_points().at(src_t->id));
            const auto kernel_t_id = workload.add_workload_tensor(src_t->desc, src_t->memory_type, src_t->memory_info, arg_desc, src_t->id);
            workload_src_tensors.push_back(kernel_t_id);
        }
        std::vector<Id> workload_dst_tensors{};
        for(const auto &dst_t_id : fused_kernel_graph.fg_dependency.dst_tensors(fg->id))
        {
            const auto dst_t = fused_kernel_graph.original_graph->get_tensor(dst_t_id);
            // Get corresponding kernel arg descriptor
            const auto arg_desc    = code.arguments.at(bp_graph.get_merge_points().at(dst_t->id));
            const auto kernel_t_id = workload.add_workload_tensor(dst_t->desc, dst_t->memory_type, dst_t->memory_info, arg_desc, dst_t->id);
            workload_dst_tensors.push_back(kernel_t_id);
        }

        workload.add_unit_workload(fg->get_root_kernel()->config().stage, code, workload_src_tensors, workload_dst_tensors);
    }

    return Status{};
}

generate_store()

Status generate_store	(	ClKernelBlueprint &	bp,
		const ClFusedKernelGraph &	fused_kernel_graph,
		const ClKernelFusionGroup &	fg
	)

NOTE: dst tensor must have already been added to the blueprint at this point

NOTE: the extra dst tensor is needed as the store kcomp requires 2 tensors. But this is irrelevant to the fused kernel graph since both tensors share the exact same info and kernel arg descriptor

NOTE: Update the merge point map to link dst_dst_id with dst_t->id instead. This is required because the get_arguments() returned by the blueprint returns the dst tensor added by the store component

Definition at line 132 of file ClFusedKernelGraph.cpp.

References add_kcomp_store(), add_tensor(), ClKernel::config(), DependencyGraph::dst_tensors(), ClFusedKernelGraph::fg_dependency, ClKernelFusionGroup::get_root_kernel(), ClKernelGraph::get_tensor(), ClKernelFusionGroup::id, ClFusedKernelGraph::original_graph, ClKernelConfig::store_type, and update_merge_point().

Referenced by generate().

{
    Status st{};
    for(const auto &dst_t_id : fused_kernel_graph.fg_dependency.dst_tensors(fg.id))
    {
        const auto dst_t = fused_kernel_graph.original_graph->get_tensor(dst_t_id);

        /// NOTE: dst tensor must have already been added to the blueprint at this point
        ArgumentID dst_id;
        st = add_tensor(bp, dst_t->desc, dst_id, dst_t->id);
        if(!bool(st))
        {
            return st;
        }
        /// NOTE: the extra dst tensor is needed as the store kcomp requires 2 tensors. But this is irrelevant to the fused kernel graph
        /// since both tensors share the exact same info and kernel arg descriptor
        ArgumentID dst_dst_id;
        st = add_tensor(bp, dst_t->desc, dst_dst_id);
        if(!bool(st))
        {
            return st;
        }
        /// NOTE: Update the merge point map to link dst_dst_id with dst_t->id instead.
        /// This is required because the get_arguments() returned by the blueprint returns the dst tensor added by the store component
        st = update_merge_point(bp, dst_dst_id, dst_t->id);
        if(!bool(st))
        {
            return st;
        }
        st = add_kcomp_store(bp, fg.get_root_kernel()->config().store_type, dst_id, dst_dst_id);
        if(!bool(st))
        {
            return st;
        }
    }
    return st;
}

get_dependency_graph()

DependencyGraph get_dependency_graph

(

const ClKernelBlueprint &

blueprint

)

Get dependency graph.

Returns

DependencyGraph

Definition at line 153 of file ClKernelBuildingAPI.cpp.

References ClKernelBlueprint::Implementation::get_graph(), and ClKernelBlueprint::impl().

Referenced by generate().

{
    return blueprint.impl().get_graph();
}

init_fusion_graph()

std::pair< Status, ClFusedKernelGraph > init_fusion_graph

(

const ClKernelGraph &

kernel_graph

)

Definition at line 83 of file ClFusedKernelGraph.cpp.

References ClFusedKernelGraph::original_graph, and traverse().

Referenced by build().

{
    ClFusedKernelGraph fused_kernel_graph{};
    fused_kernel_graph.original_graph = &kernel_graph; // Create a copy of the original kernel graph
    fused_kernel_graph.fg_dependency  = DependencyGraph();
    // Initialize all fusion groups
    for(const auto &kernel : traverse(kernel_graph))
    {
        fused_kernel_graph.add_fusion_group({ kernel });
    }
    return { Status{}, fused_kernel_graph };
}

is_in()

bool arm_compute::experimental::dynamic_fusion::is_in	(	const T &	v,
		const std::vector< T > &	vec
	)

Definition at line 41 of file DependencyGraph.h.

References arm_compute::mlgo::parser::end().

Referenced by ClFusedKernelGraph::can_fuse(), ClFusedKernelGraph::fuse(), DependencyGraph::get_root_ops(), DependencyGraph::path_exists_from_op_to_op(), DependencyGraph::topological_partition(), and DependencyGraph::try_add_operator_as_linear().

{
    return std::find(std::begin(vec), std::end(vec), v) != std::end(vec);
}

operator<() [1/2]

bool operator<	(	const OpTensor &	t0,
		const OpTensor &	t1
	)

Provide order of OpTensor by checking if t0 is "lower than" t1.

Parameters

[in]	t0	OpTensor
[in]	t1	OpTensor

Returns

true if t0 is lower than t1

false otherwise

Definition at line 84 of file OperatorGraph.cpp.

References OpTensor::id().

{
    return t0.id() < t1.id();
}

operator<() [2/2]

bool operator<	(	const Operator &	op0,
		const Operator &	op1
	)

Provide order of Operator by checking if op0 is "lower than" op1.

Parameters

[in]	op0	Operator
[in]	op1	Operator

Returns

true if op0 is lower than op1

false otherwise

Definition at line 99 of file OperatorGraph.cpp.

References Operator::id().

{
    return op0.id() < op1.id();
}

operator<<() [1/3]

inline ::std::ostream& arm_compute::experimental::dynamic_fusion::operator<<	(	::std::ostream &	os,
		const CLBuildOptions::StringSet &	build_opts
	)

Definition at line 37 of file Utils.h.

{
    for(const auto &opt : build_opts)
    {
        os << opt << ",";
    }
    return os;
}

operator<<() [2/3]

inline ::std::ostream& arm_compute::experimental::dynamic_fusion::operator<<	(	::std::ostream &	os,
		const CLBuildOptions &	cl_build_opts
	)

Definition at line 45 of file Utils.h.

References CLBuildOptions::options().

{
    os << cl_build_opts.options();
    return os;
}

operator<<() [3/3]

inline ::std::ostream& arm_compute::experimental::dynamic_fusion::operator<<	(	::std::ostream &	os,
		const ClKernelCode &	code
	)

Definition at line 57 of file Utils.h.

References ClKernelCode::build_options, ClKernelCode::code, and ClKernelCode::name.

{
    os << "name: " << code.name << std::endl;
    os << "code: " << code.code << std::endl;
    os << "build_opts: " << code.build_options << std::endl;
    return os;
}

operator==() [1/7]

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

Definition at line 31 of file GpuKernelArgument.cpp.

References GpuKernelArgumentInfo::type.

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

operator==() [2/7]

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

inline

Definition at line 56 of file IGpuKernelComponent.h.

References KernelProperties::stage().

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

operator==() [3/7]

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

inline

Definition at line 126 of file GpuWorkloadSourceCode.h.

References UnitWorkloadStage::stage.

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

operator==() [4/7]

bool operator==	(	const OpTensor &	t0,
		const OpTensor &	t1
	)

Definition at line 103 of file OperatorGraphImpl.cpp.

References OpTensor::id().

Referenced by ClDirectConv2dKernel::ClDirectConv2dKernel(), ClElementwiseKernel::ClElementwiseKernel(), ClFloorKernel::ClFloorKernel(), Conv2dContent::Conv2dContent(), ElementwiseContent::ElementwiseContent(), and FloorContent::FloorContent().

{
    return std::make_tuple(t0.id()) == std::make_tuple(t1.id());
}

operator==() [5/7]

bool operator==	(	const Conv2dDescriptor &	conv2d0,
		const Conv2dDescriptor &	conv2d1
	)

Definition at line 107 of file OperatorGraphImpl.cpp.

References Conv2dDescriptor::dilation, and Conv2dDescriptor::stride.

{
    return std::make_tuple(conv2d0.stride, conv2d0.dilation) == std::make_tuple(conv2d1.stride, conv2d1.dilation);
}

operator==() [6/7]

bool operator==	(	const ElementwiseDescriptor &	ed0,
		const ElementwiseDescriptor &	ed1
	)

Definition at line 112 of file OperatorGraphImpl.cpp.

References ElementwiseDescriptor::op.

{
    return ed0.op == ed1.op; // Compare Arithmatic Operations of two ElementwiseDescriptor objects
}

operator==() [7/7]

bool operator==	(	const FloorDescriptor &	,
		const FloorDescriptor &
	)

Definition at line 117 of file OperatorGraphImpl.cpp.

{
    return std::make_tuple() == std::make_tuple(); // Currently two Floor ops are always the same
}

set_tile_info()

Status set_tile_info	(	ClKernelBlueprint &	bp,
		const TileDescriptor &	tile_info
	)

Definition at line 135 of file ClKernelBuildingAPI.cpp.

References ClKernelBlueprint::impl(), and ClKernelBlueprint::Implementation::set_tile_info().

Referenced by generate().

{
    bp.impl().set_tile_info(tile_info);
    return Status{};
}

to_string() [1/2]

std::string arm_compute::experimental::dynamic_fusion::to_string ( const CLBuildOptions &  cl_build_opts )

inline

Definition at line 51 of file Utils.h.

References caffe_mnist_image_extractor::str.

Referenced by ClKernelBlueprint::Implementation::get_graph(), ClTemplateWriter::get_tensors(), ClDirectConvolutionKernelComponent::name(), ClFloorKernelComponent::name(), and ClElementwiseKernelComponent::name().

{
    std::stringstream str;
    str << cl_build_opts;
    return str.str();
}

to_string() [2/2]

std::string arm_compute::experimental::dynamic_fusion::to_string ( const ClKernelCode &  code )

inline

Definition at line 64 of file Utils.h.

References caffe_mnist_image_extractor::str.

{
    std::stringstream str;
    str << code;
    return str.str();
}

translate()

Status translate	(	ClKernelGraph &	kernel_graph,
		const OperatorGraph::Implementation &	op_graph
	)

Definition at line 410 of file OperatorGraphImpl.cpp.

References ARM_COMPUTE_RETURN_ON_ERROR, and traverse().

Referenced by build(), ElementwiseContent::complexity(), FloorContent::complexity(), and Conv2dContent::set_method().

{
    for(const auto &op : traverse(op_graph))
    {
        const auto st = op->translate(kernel_graph);
        ARM_COMPUTE_RETURN_ON_ERROR(st);
    }
    return Status{};
}

traverse() [1/7]

std::vector< const ClKernel * > traverse

(

const ClKernelFusionGroup &

group

)

Definition at line 50 of file ClFusedKernelGraph.cpp.

References ClKernelFusionGroup::fused_kernels, ClKernelFusionGroup::graph, arm_compute::test::validation::pack, and DependencyGraph::topological_sort().

Referenced by ClKernelBlueprint::Implementation::build_config_id(), ClKernelBlueprint::Implementation::build_kernel_name(), ClKernelBlueprint::Implementation::build_options(), fuse(), ClFusedKernelGraph::fuse(), generate(), ClKernelBlueprint::Implementation::get_graph(), init_fusion_graph(), and translate().

{
    std::vector<const ClKernel *> kernels;
    const auto                    sorted = group.graph.topological_sort();
    for(const auto &pack : sorted.second)
    {
        kernels.push_back(group.fused_kernels.at(pack.op));
    }
    return kernels;
}

traverse() [2/7]

std::vector< const ClKernelFusionGroup * > traverse

(

const ClFusedKernelGraph &

graph

)

Definition at line 61 of file ClFusedKernelGraph.cpp.

References ClFusedKernelGraph::fg_dependency, ClFusedKernelGraph::fusion_groups, arm_compute::test::validation::pack, and DependencyGraph::topological_sort().

{
    std::vector<const ClKernelFusionGroup *> kernels;
    const auto                               sorted = graph.fg_dependency.topological_sort();
    for(const auto &pack : sorted.second)
    {
        kernels.push_back(graph.fusion_groups.at(pack.op).get());
    }
    return kernels;
}

traverse() [3/7]

std::vector< ClKernelFusionGroup * > traverse

(

ClFusedKernelGraph &

graph

)

Definition at line 72 of file ClFusedKernelGraph.cpp.

References ClFusedKernelGraph::fg_dependency, ClFusedKernelGraph::fusion_groups, arm_compute::test::validation::pack, and DependencyGraph::topological_sort().

{
    std::vector<ClKernelFusionGroup *> kernels;
    const auto                         sorted = graph.fg_dependency.topological_sort();
    for(const auto &pack : sorted.second)
    {
        kernels.push_back(graph.fusion_groups.at(pack.op).get());
    }
    return kernels;
}

traverse() [4/7]

std::vector< const ClKernel * > traverse

(

const ClKernelGraph &

graph

)

Definition at line 247 of file ClKernelGraph.cpp.

References ClKernelGraph::graph, ClKernelGraph::kernels, arm_compute::test::validation::pack, and DependencyGraph::topological_sort().

{
    std::vector<const ClKernel *> kernels;
    const auto                    sorted = graph.graph.topological_sort();
    for(const auto &pack : sorted.second)
    {
        kernels.push_back(graph.kernels.at(pack.op).get());
    }
    return kernels;
}

traverse() [5/7]

std::vector< ClKernel * > traverse

(

ClKernelGraph &

graph

)

Definition at line 258 of file ClKernelGraph.cpp.

References ClKernelGraph::graph, ClKernelGraph::kernels, arm_compute::test::validation::pack, and DependencyGraph::topological_sort().

{
    std::vector<ClKernel *> kernels;
    const auto              sorted = graph.graph.topological_sort();
    for(const auto &pack : sorted.second)
    {
        kernels.push_back(graph.kernels.at(pack.op).get());
    }
    return kernels;
}

traverse() [6/7]

std::vector< const OperatorContent * > traverse

(

const OperatorGraph::Implementation &

graph

)

Definition at line 388 of file OperatorGraphImpl.cpp.

References OperatorGraph::Implementation::graph, OperatorGraph::Implementation::operators, arm_compute::test::validation::pack, and DependencyGraph::topological_sort().

{
    std::vector<const OperatorContent *> ops;
    const auto                           sorted = graph.graph.topological_sort();
    for(const auto &pack : sorted.second)
    {
        ops.push_back(graph.operators.at(pack.op).get());
    }
    return ops;
}

traverse() [7/7]

std::vector< OperatorContent * > traverse

(

OperatorGraph::Implementation &

graph

)

Definition at line 399 of file OperatorGraphImpl.cpp.

References OperatorGraph::Implementation::graph, OperatorGraph::Implementation::operators, arm_compute::test::validation::pack, and DependencyGraph::topological_sort().

{
    std::vector<OperatorContent *> ops;
    const auto                     sorted = graph.graph.topological_sort();
    for(const auto &pack : sorted.second)
    {
        ops.push_back(graph.operators.at(pack.op).get());
    }
    return ops;
}

tune_static()

Status tune_static	(	ClExecutionDescriptor &	,
		const ClKernelCode &
	)

Definition at line 157 of file ClKernelBuildingAPI.cpp.

{
    return Status{};
}

update_merge_point()

Status update_merge_point	(	ClKernelBlueprint &	,
		ArgumentID	t_id,
		ArgumentID	merge_point
	)

Update existing merge tensor merge_point to point to t_id.

Parameters

t_id
merge_point

Returns

Status

Definition at line 130 of file ClKernelBuildingAPI.cpp.

References ClKernelBlueprint::impl(), and ClKernelBlueprint::Implementation::update_merge_point().

Referenced by generate_store().

{
    return bp.impl().update_merge_point(t_id, merge_point);
}

validate()

Status validate

(

const OperatorGraph &

op_graph

)

Return the validity of op_graph, usually after performing an operation (e.g.

add_tensor) on it

Parameters

[in,out]

op_graph

OperatorGraph to be validated

Returns

Status

Examples:

dynamic_fusion/cl_fused_conv2d_elementwise_add.cpp.

Definition at line 121 of file OperatorGraph.cpp.

References OperatorGraph::impl(), and OperatorGraph::Implementation::status.

Referenced by build(), ClDirectConv2dKernel::ClDirectConv2dKernel(), ClElementwiseKernel::ClElementwiseKernel(), ClFloorKernel::ClFloorKernel(), CpuGemm::configure(), arm_compute::test::validation::DATA_TEST_CASE(), CpuDepthwiseConv2d::get_depthwiseconvolution_function(), arm_compute::test::validation::TEST_CASE(), CPPSplit< CLSlice, ICLTensor >::validate(), CpuDepthwiseConv2d::validate(), ClDirectConv2d::validate(), CLSynthetizeOperator< ClGemmMatrixMultiplyReshapedOnlyRhsKernel >::validate(), NESynthetizeFunction< K >::validate(), CLSynthetizeFunction< K >::validate(), NEQLSTMLayer::validate(), CLQLSTMLayer::validate(), arm_compute::graph::backends::detail::validate_arg_min_max_layer(), arm_compute::graph::backends::detail::validate_bounding_box_transform_layer(), arm_compute::graph::backends::detail::validate_channel_shuffle_layer(), arm_compute::graph::backends::detail::validate_convolution_layer(), arm_compute::graph::backends::detail::validate_depth_to_space_layer(), arm_compute::graph::backends::detail::validate_depthwise_convolution_layer(), arm_compute::graph::backends::detail::validate_dequantization_layer(), arm_compute::graph::backends::detail::validate_detection_output_layer(), arm_compute::graph::backends::detail::validate_detection_post_process_layer(), arm_compute::graph::backends::detail::validate_eltwise_Layer(), arm_compute::graph::backends::detail::validate_fused_convolution_with_post_op(), arm_compute::graph::backends::detail::validate_generate_proposals_layer(), arm_compute::graph::backends::detail::validate_l2_normalize_layer(), arm_compute::graph::backends::detail::validate_normalize_planar_yuv_layer(), arm_compute::graph::backends::detail::validate_pad_layer(), arm_compute::graph::backends::detail::validate_permute_layer(), arm_compute::graph::backends::detail::validate_prelu_layer(), arm_compute::graph::backends::detail::validate_priorbox_layer(), arm_compute::graph::backends::detail::validate_quantization_layer(), arm_compute::graph::backends::detail::validate_reduction_operation_layer(), arm_compute::graph::backends::detail::validate_reorg_layer(), arm_compute::graph::backends::detail::validate_reshape_layer(), arm_compute::graph::backends::detail::validate_roi_align_layer(), arm_compute::graph::backends::detail::validate_slice_layer(), arm_compute::graph::backends::detail::validate_strided_slice_layer(), and arm_compute::graph::backends::detail::validate_unary_eltwise_layer().

{
    return graph.impl()->status;
}