#include <tvm/graph/abstract/Node.h>

Inheritance diagram for tvm::graph::abstract::Node< T >:

[legend]

Collaboration diagram for tvm::graph::abstract::Node< T >:

[legend]

Protected Member Functions
template<typename EnumT , typename U , typename... Args>
void	registerUpdates (EnumT u, void(U::*fn)(), Args... args)

template<typename EnumT , typename U >
void	registerUpdates (EnumT u, void(U::*fn)())

template<typename U = T, typename EnumO , typename EnumU >
void	addOutputDependency (EnumO o, EnumU u)

template<typename U = T, typename EnumO , typename EnumU >
void	addOutputDependency (std::initializer_list< EnumO > os, EnumU u)

template<typename U = T, typename EnumU1 , typename EnumU2 >
void	addInternalDependency (EnumU1 uDependent, EnumU2 u)

template<typename U = T, typename EnumU , typename S , typename EnumO , typename... Args>
void	addInputDependency (EnumU u, std::shared_ptr< S > source, EnumO i, Args... args)

template<typename U = T, typename EnumU , typename S , typename EnumO , typename... Args, typename std::enable_if< std::is_base_of< abstract::Outputs, S >::value, int >::type = 0>
void	addInputDependency (EnumU u, S &source, EnumO i, Args... args)

template<typename U = T, typename EnumO , typename S , typename EnumI >
void	addDirectDependency (EnumO o, std::shared_ptr< S > source, EnumI i)

template<typename U = T, typename EnumO , typename S , typename EnumI , typename std::enable_if< std::is_base_of< abstract::Outputs, S >::value, int >::type = 0>
void	addDirectDependency (EnumO o, S &source, EnumI i)

Additional Inherited Members
Public Types inherited from tvm::graph::internal::AbstractNode
enum class	Update_

using	UpdateParent = AbstractNode

using	UpdateBase = AbstractNode

Public Types inherited from tvm::graph::internal::Inputs
using	inputs_t = std::unordered_map< abstract::Outputs *, std::set< int > >

using	store_t = std::unordered_set< std::shared_ptr< abstract::Outputs > >

Public Types inherited from tvm::graph::abstract::Outputs
enum class	Output_

using	OutputParent = Outputs

using	OutputBase = Outputs

Public Member Functions inherited from tvm::graph::internal::AbstractNode
template<typename EnumT >
bool	isUpdateEnabled (EnumT e) const

virtual bool	isUpdateStaticallyEnabled (int) const

virtual bool	isUpdateCustomEnabled (int) const

virtual	~AbstractNode ()=default

void	update (int i)

Public Member Functions inherited from tvm::graph::internal::Inputs
virtual	~Inputs ()=default

template<typename T , typename EnumI , typename... Args>
void	addInput (std::shared_ptr< T > source, EnumI i, Args... args)

template<typename T , typename EnumI , typename... Args, typename std::enable_if< std::is_base_of< abstract::Outputs, T >::value, int >::type = 0>
void	addInput (T &source, EnumI i, Args... args)

template<typename T >
void	removeInput (T *source)

template<typename T , typename... Args>
void	removeInput (T *source, Args... args)

template<typename T >
Iterator	getInput (T *source)

template<typename T >
Iterator	getInput (const std::shared_ptr< T > &source)

Public Member Functions inherited from tvm::graph::abstract::Outputs
virtual	~Outputs ()=default

template<typename EnumT >
bool	isOutputEnabled (EnumT e) const

bool	isOutputEnabled (int i) const

virtual bool	isOutputStaticallyEnabled (int) const

virtual bool	isOutputCustomEnabled (int) const

Static Public Member Functions inherited from tvm::graph::internal::AbstractNode
static constexpr const char *	UpdateName (Update_)

template<typename EnumT >
static constexpr bool	UpdateStaticallyEnabled (EnumT)

Static Public Member Functions inherited from tvm::graph::abstract::Outputs
static constexpr const char *	OutputName (Output_)

template<typename EnumT >
static constexpr bool	OutputStaticallyEnabled (EnumT)

Static Public Attributes inherited from tvm::graph::internal::AbstractNode
static constexpr unsigned int	UpdateSize = 0

static constexpr auto	UpdateBaseName = "AbstractNode"

Static Public Attributes inherited from tvm::graph::abstract::Outputs
static constexpr unsigned int	OutputSize = 0

static constexpr auto	OutputBaseName = "Outputs"

Protected Types inherited from tvm::graph::internal::AbstractNode
using	input_dependency_t = std::map< Outputs *, std::set< int > >

Protected Attributes inherited from tvm::graph::internal::AbstractNode
std::map< int, std::function< void(AbstractNode &)> >	updates_

std::map< int, std::vector< int > >	outputDependencies_

std::map< int, std::vector< int > >	internalDependencies_

std::map< int, input_dependency_t >	inputDependencies_

std::map< int, std::pair< Outputs *, int > >	directDependencies_

Protected Attributes inherited from tvm::graph::abstract::Outputs
bool	is_node_ = false

Detailed Description

template<typename T>
class tvm::graph::abstract::Node< T >

Node is the concrete base for AbstractNode.

It represents an entity that uses input signals to compute output signals using update functions and the dependencies between these quantities.

Member Function Documentation

◆ addDirectDependency() [1/2]

template<typename T >

template<typename U = T, typename EnumO , typename S , typename EnumI , typename std::enable_if< std::is_base_of< abstract::Outputs, S >::value, int >::type = 0>

void tvm::graph::abstract::Node< T >::addDirectDependency	(	EnumO	o,
		S &	source,
		EnumI	i
	)

protected

Add a dependency of an output to an input signal and its source

The lifetime of source should be guaranteed by the caller

This is used when an output directly use the input signal without requiring an update, and a cache. This is the case when an output directly forward an input, and it should be the only use-case.

It is not possible for an output to have a direct and some update dependencies at the same time.

◆ addDirectDependency() [2/2]

template<typename T >

template<typename U = T, typename EnumO , typename S , typename EnumI >

void tvm::graph::abstract::Node< T >::addDirectDependency	(	EnumO	o,
		std::shared_ptr< S >	source,
		EnumI	i
	)

protected

Add a dependency of an output to an input signal and its source

This is used when an output directly use the input signal without requiring an update, and a cache. This is the case when an output directly forward an input, and it should be the only use-case.

It is not possible for an output to have a direct and some update dependencies at the same time.

◆ addInputDependency() [1/2]

template<typename T >

template<typename U = T, typename EnumU , typename S , typename EnumO , typename... Args, typename std::enable_if< std::is_base_of< abstract::Outputs, S >::value, int >::type = 0>

void tvm::graph::abstract::Node< T >::addInputDependency	(	EnumU	u,
		S &	source,
		EnumO	i,
		Args...	args
	)

protected

Add a dependency of an update function to multiple input signals from a source

The lifetime of source should be guaranteed by the caller

◆ addInputDependency() [2/2]

template<typename T >

template<typename U = T, typename EnumU , typename S , typename EnumO , typename... Args>

void tvm::graph::abstract::Node< T >::addInputDependency	(	EnumU	u,
		std::shared_ptr< S >	source,
		EnumO	i,
		Args...	args
	)

protected

Add a dependency of an update function to multiple input signals from a source

◆ addInternalDependency()

template<typename T >

template<typename U = T, typename EnumU1 , typename EnumU2 >

void tvm::graph::abstract::Node< T >::addInternalDependency	(	EnumU1	uDependent,
		EnumU2	u
	)

protected

Add a dependency between two update calls.

The first argument of this function depends on the second argument.

◆ addOutputDependency() [1/2]

template<typename T >

template<typename U = T, typename EnumO , typename EnumU >

void tvm::graph::abstract::Node< T >::addOutputDependency	(	EnumO	o,
		EnumU	u
	)

protected

Add a dependency of an output to an update call

It is not possible for an output to have a direct and some update dependencies at the same time.

◆ addOutputDependency() [2/2]

template<typename T >

template<typename U = T, typename EnumO , typename EnumU >

void tvm::graph::abstract::Node< T >::addOutputDependency	(	std::initializer_list< EnumO >	os,
		EnumU	u
	)

protected

Add a dependency of multiple outputs to an update call

◆ registerUpdates() [1/2]

template<typename T >

template<typename EnumT , typename U >

void tvm::graph::abstract::Node< T >::registerUpdates	(	EnumT	u,
		void(U::*)()	fn
	)

protected

Register a single update

◆ registerUpdates() [2/2]

template<typename T >

template<typename EnumT , typename U , typename... Args>

void tvm::graph::abstract::Node< T >::registerUpdates	(	EnumT	u,
		void(U::*)()	fn,
		Args...	args
	)

protected

Register updates

An update is formed by its unique id (from an enum type) and the related object method.

The documentation for this class was generated from the following file:

include/tvm/graph/abstract/Node.h

Protected Member Functions

Additional Inherited Members

Detailed Description

template<typename T> class tvm::graph::abstract::Node< T >

Member Function Documentation

◆ addDirectDependency() [1/2]

◆ addDirectDependency() [2/2]

◆ addInputDependency() [1/2]

◆ addInputDependency() [2/2]

◆ addInternalDependency()

◆ addOutputDependency() [1/2]

◆ addOutputDependency() [2/2]

◆ registerUpdates() [1/2]

◆ registerUpdates() [2/2]

template<typename T>
class tvm::graph::abstract::Node< T >