arm_compute::experimental::dynamic_fusion Namespace Reference

Data Structures
class	AddContent
struct	AddDescriptor
	Descriptor for Addition operation. More...
struct	AuxMemoryInfo
	Memory Info for a WorkloadTensor of Auxiliary memory type. More...
struct	ClActivationKernelDescriptor
struct	ClAddKernel
class	ClAuxTensorData
	Holder of any auxiliary CLTensors required by a ClWorkload. More...
struct	ClCodeBuilderContext
	All information required for building the ClKernelCode. More...
class	ClCompositeKernel
class	ClCompositeOperator
	Operator runtime to run a ClWorkload. More...
struct	ClDirectConv2dKernel
struct	ClDirectConv2dKernelDescriptor
class	ClDirectConvolutionKernelComponent
class	ClElementwiseAddKernelComponent
struct	ClEltwiseAddKernelDescriptor
struct	ClExecutionDescriptor
	Descriptor containing information required to run a single ClWorkload. More...
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
struct	ClKernelTensor
class	ClStoreBlockBoundaryAwareKernelComponent
class	ClStoreIndirectWidthSelectKernelComponent
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...
struct	ClWorkloadTensor
	A descriptor of ClWorkload Tensors. 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...
struct	GpuInfo
	GPU information for ClWorkloadContext. More...
class	IClKernelComponent
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	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	Padding2D
	Padding information for 2D operations like Conv2dDescriptor. More...
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...
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	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

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 }
	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 }

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_add (OperatorGraph &graph, const AddDescriptor &desc, OpTensor lhs, OpTensor rhs, OpTensor dst)
	Add op Add to graph, and optionally describes fusion through passing of intermediate OpTensor s. More...
bool	operator== (const OpTensor &t0, const OpTensor &t1)
bool	operator== (const Padding2D &pad0, const Padding2D &pad1)
bool	operator== (const Conv2dDescriptor &conv2d0, const Conv2dDescriptor &conv2d1)
bool	operator== (const AddDescriptor &, const AddDescriptor &)
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_add (ClKernelBlueprint &, const ClEltwiseAddKernelDescriptor &, ArgumentID src0_id, ArgumentID src1_id, ArgumentID &dst_id)
	Component: Eltwise Add. 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)

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 = 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 413 of file Common.h.

Id

using Id = DependencyGraph::Id

Definition at line 230 of file ClKernelGraph.h.

OpTensorBinding

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

Map OpTensor handles to their corresponding ITensor memory.

Definition at line 44 of file ClCompositeOperator.h.

Enumeration Type Documentation

ClippingStrategy

enum ClippingStrategy

strong

Enumerator
TOP_LEFT
TOP_RIGHT
BOTTOM_LEFT
BOTTOM_RIGHT

Definition at line 61 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
};

MemoryType

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

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 93 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 70 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 75 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_add()

Status add_kcomp_eltwise_add	(	ClKernelBlueprint &	kernel_blueprint,
		const ClEltwiseAddKernelDescriptor &	,
		ArgumentID	src0_id,
		ArgumentID	src1_id,
		ArgumentID &	dst_id
	)

Component: Eltwise Add.

Definition at line 58 of file ClKernelBuildingAPI.cpp.

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

Referenced by ClAddKernel::generate().

{
    kernel_blueprint.impl().add_component(
        std::make_unique<ClElementwiseAddKernelComponent>(
            &kernel_blueprint,
            SharedVarLink{ src0_id, SharedVarIO::Input },
            SharedVarLink{ src1_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 91 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_add()

Operator add_op_elementwise_add	(	OperatorGraph &	graph,
		const AddDescriptor &	desc,
		OpTensor	lhs,
		OpTensor	rhs,
		OpTensor	dst
	)

Add op Add 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<AddContent>(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(), ClAddKernel::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, ClWorkload::op_tensor_id_lut, arm_compute::RUNTIME_ERROR, 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 126 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(), ClDirectConv2dKernel::configure(), ClDirectConvolutionKernelComponent::generate_build_options(), and ClDirectConv2dKernel::run_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(), ClAddKernel::ClAddKernel(), ClDirectConv2dKernel::ClDirectConv2dKernel(), and ClKernel::ClKernel().

{
    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 139 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(), and DependencyGraph::path_exists_from_op_to_op().

{
    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/4]

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

Definition at line 103 of file OperatorGraphImpl.cpp.

References OpTensor::id().

Referenced by AddContent::AddContent(), ClAddKernel::ClAddKernel(), ClDirectConv2dKernel::ClDirectConv2dKernel(), ClKernel::ClKernel(), Conv2dContent::Conv2dContent(), and OperatorContent::OperatorContent().

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

operator==() [2/4]

bool operator==	(	const Padding2D &	pad0,
		const Padding2D &	pad1
	)

Definition at line 107 of file OperatorGraphImpl.cpp.

References Padding2D::bottom, Padding2D::left, Padding2D::right, and Padding2D::top.

{
    return std::make_tuple(pad0.top, pad0.right, pad0.bottom, pad0.left) == std::make_tuple(pad1.top, pad1.right, pad1.bottom, pad1.left);
}

operator==() [3/4]

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

Definition at line 111 of file OperatorGraphImpl.cpp.

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

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

operator==() [4/4]

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

Definition at line 116 of file OperatorGraphImpl.cpp.

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

set_tile_info()

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

Definition at line 121 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_data_extractor::str.

Referenced by ClKernelBlueprint::Implementation::get_graph(), ClElementwiseAddKernelComponent::name(), and ClDirectConvolutionKernelComponent::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_data_extractor::str.

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

translate()

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

Definition at line 373 of file OperatorGraphImpl.cpp.

References ARM_COMPUTE_RETURN_ON_ERROR, and traverse().

Referenced by build(), AddContent::complexity(), OperatorContent::OperatorContent(), 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 195 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 205 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 351 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 362 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 143 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 116 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(), ClAddKernel::ClAddKernel(), ClDirectConv2dKernel::ClDirectConv2dKernel(), 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(), 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;
}