GXF App C++ APIs
Arg
-
struct nvidia::gxf::ArgInfo
Holds type information of an Arg.
-
gxf_parameter_type_t type
The type of the Arg.
-
std::string type_name
The name of the Arg’s type.
-
int32_t rank
The rank of the Arg.
-
std::array<int32_t, ParameterInfo<int32_t>::kMaxRank> shape
The shape of the Arg.
-
gxf_parameter_type_t type
-
struct nvidia::gxf::ArgOverride
A template struct for overriding ArgInfo for various Arg types.
-
static Expected<void> apply(ArgInfo &info)
Applies the ArgOverride to the given ArgInfo.
- Parameters
ArgInfo& info – The ArgInfo to apply the override to.
- Returns
Expected<void> Success or error code on failure
-
static ExpectedYAML::Node wrap(const T &value)
Wraps the given arg value in a YAML node.
- Parameters
const T& value – The value to wrap.
- Returns
An Expected with a YAML node on success, or an Unexpected with an error code on failure.
The following template specializations have been implemented for the ArgOverride struct in arg.hpp:
ArgOverride<T>ArgOverride<Handle<T>>ArgOverride<std::vector<T>>ArgOverride<std::array<T,N>>ArgOverride<ProxyComponent>These specializations cover a wide range of parameter types, including scalar types, handles, arrays, vectors, and proxy components.
-
static Expected<void> apply(ArgInfo &info)
-
class nvidia::gxf::Arg
Argument interface to enable configuring parameters in GXF Components from the application layer. All parameter types from :cpp:enum::gxf_parameter_type_t enum is supported.
-
Arg(const std::string &key)
Constructor for an argument with a given key.
-
template<typename T>
Arg(const std::string &key, const T &value) Constructor for an argument with a given key and value.
-
Arg(const std::string &key, const char *value)
Constructor for an argument with a given key and string literal value.
-
template<typename T>
Arg(const std::string &key, const Handle<T> &value) Constructor for an argument with a given key and handle to a component as value.
-
Arg(const std::string &key, const ProxyComponent &value)
Constructor for an argument with a given key and a proxy component.
-
template<typename T, typename = std::enable_if_t<!std::is_lvalue_reference<T>::value>>
Arg(const std::string &key, T &&value) Constructor for an argument with a given key and rvalue reference to a value.
-
template<typename T, typename = std::enable_if_t<!std::is_lvalue_reference<T>::value>>
Arg(const std::string &key, Handle<T> &&value) Constructor for an argument with a given key and rvalue reference to a handle to a component as value.
-
Arg(const std::string &key, ProxyComponent &&value)
Constructor for an argument with a given key and rvalue reference to a proxy component.
-
template<typename T, typename = std::enable_if_t<!std::is_same_v<Arg, std::decay_t<T>>>>
Arg &operator=(const T &value) Assignment operator for an argument with a given value.
-
template<typename T, typename = std::enable_if_t<!std::is_same_v<Arg, std::decay_t<T>>>>
Arg &operator=(const Handle<T> &value) Assignment operator for an argument with a given handle to a component as value.
-
Arg &operator=(ProxyComponent &value)
Assignment operator for an argument with a given proxy component.
-
template<typename T, typename = std::enable_if_t<!std::is_same_v<Arg, std::decay_t<T>> && !std::is_lvalue_reference<T>::value>>
Arg &&operator=(T &&value) Move assignment operator for an argument with a given rvalue reference to a value.
-
template<typename T, typename = std::enable_if_t<!std::is_same_v<Arg, std::decay_t<Handle<T>>> && !std::is_lvalue_reference<Handle<T>>::value>>
Arg &&operator=(Handle<T> &&value) Move assignment operator for an argument with a given rvalue reference to a handle to a component as value.
-
Arg &&operator=(ProxyComponent &&value)
Move assignment operator for an argument with a given rvalue reference to a proxy component.
-
template<typename T, typename = std::enable_if_t<IsDefaultConstructible_v<T>>>
T as() const Method to retrieve the value of the argument as a given type.
-
const gxf_uid_t handle_uid() const
Method to retrieve the handle UID of the argument.
-
const gxf_tid_t handle_tid() const
Method to retrieve the handle TID of the argument.
-
const char *key() const
Method to retrieve the key of the argument.
-
const std::string arg_type_name() const
Method to retrieve the type name of the argument.
-
const YAML::Node yaml_node() const
Method to retrieve the YAML node of the argument.
-
const int32_t rank() const
Method to retrieve the rank of the argument.
-
const std::array<int32_t, ParameterInfo<int32_t>::kMaxRank> shape() const
Method to retrieve the shape of the argument.
-
const gxf_parameter_type_t parameter_type() const
Method to retrieve the parameter type of the argument.
-
bool has_value() const
Method to retrieve the argument has a value assigned
-
std::any value() const
Method to retrieve the value of the argument in a std::any object
-
Arg(const std::string &key)
Arg Parse
-
template<typename T, typename First, typename ...Rest>
std::vector<T> parseArgsOfType(const First &first, const Rest&... rest) Parses the incoming parameter pack of arguments for objects of type T
- Parameters
T – Type of parameter to be filtered from the parameter pack
- Returns
std::vector<T> List of objects of type T
-
Expected<void> applyArg(Handle<Component> component, const Arg &arg)
- Parameters
component – Handle to a valid component
arg – Arg to be applied on the component
- Returns
Expected<void> Success or error code on failure
-
Expected<Arg> findArg(const std::vector<Arg> &args, const std::string &key, const gxf_parameter_type_t type)
- Parameters
args – Input Arg list
key – Arg key to search
type – parameter type of the Arg
- Returns
Expected<Arg> Arg object if found, error code on failure
Application
-
class nvidia::gxf::Application
A class representing an application for GXF. This class provides a convenient way to create and manage GXF applications imperatively. Users implement a virtual compose() api where individual building blocks of an application is constructed, configured and connected with each other.
-
Application()
Constructor for an application. This constructor initializes an application with no segments or entities.
-
~Application()
Destructor for an application. This destructor cleans up any resources that were allocated by the application.
-
Application(const Application&) = delete
Copy constructor for an application. This constructor is deleted to prevent copying of applications.
-
Application &operator=(const Application&) = delete
Copy assignment operator for an application. This operator is deleted to prevent copying of applications.
-
Application(Application&&) = delete
Move constructor for an application. This constructor is deleted to prevent moving applications.
-
Application &operator=(Application&&) = delete
Move assignment operator for an application. This operator is deleted to prevent moving applications.
-
virtual void compose()
A virtual function that is called to compose the application. This function is where the segments and entities of the application are created and configured.
-
Expected<void> setConfig(const std::string &file_path)
Function to set the configuration of the application. This function sets the configuration of the application by loading it from a file.
- Parameters
file_path – Absolute path to the yaml config file for segments distributed execution
- Returns
Expected<void> Success or error code on failure
-
Expected<void> setConfig(int argc, char **argv)
Function to set the configuration of the application. This function sets the configuration of the application by parsing it from command line arguments.
- Parameters
argc – CLI argument count
argv – CLI argument array, the second is config file path for segments distributed execution
- Returns
Expected<void> Success or error code on failure
Function to create a segment in the application. This function creates a new segment in the application with the specified name. The graph for the segment will be composed() after creation. SegmentT is a valid type segment type.
- Parameters
name – Name of the segment
- Returns
Expected<void> Success or error code on failure
-
Expected<void> loadExtensionManifest(const char *manifest)
Function to load an extension manifest.
- Parameters
manifest – path to manifest file with list of extensions
- Returns
Expected<void> Success or error code on failure
-
Expected<void> connect(SegmentPtr source, SegmentPtr target, std::vector<SegmentPortPair> port_maps)
This function connects two segments by mapping their ports. It adds a UCX connection between two entities with many : many tx and rx Ucx Transmitter and Ucx Receiver components are added to the source and target entities in both of the segments.
- Parameters
source – Segment with the entity transmitting the message
target – Segment with the entity receiving entity. A message available term is added along with the Ucx Receiver
port_maps – Segment port map with entity and queue name to be used for connection.
- Returns
Expected<void> Success or error code on failure
-
gxf_result_t nvidia::gxf::Application::setSegmentSeverity(const char *name, gxf_severity_t severity)
Sets the severity level of the logs (corresponding to GXF_LOG_* logging macros) for a specific segment
- Parameters
name – The name of the segment.
severity – The severity level.
- Returns
A gxf_result_t indicating success or failure.
-
Expected<void> run()
A blocking api to run the graph. If the application contains multiple segments, each segment is launched asynchronously and this thread is blocked until each one of the segments have finished execution. If the graph contains multiple entities, then this thread is blocked until the graph execution is complete.
- Returns
Expected<void> Success or error code on failure
-
Expected<void> runAsync()
A non blocking api call to run an application. If the application contains multiple segments, each segment is launched asynchronously.
- Returns
Expected<void> Success or error code on failure
-
Expected<void> interrupt()
A non blocking api to stop all running running segments or entities.
- Returns
Expected<void> Success or error code on failure
-
Expected<void> wait()
A blocking API to waits until the graph execution has completed
- Returns
Expected<void> Success or error code on failure
-
template<typename ...Args>
Expected<void> setWorker(const std::string &name, Args... args) In-place add a GraphWorker Component into Application’s root context, in which case Application’s context should only hold and run GraphWorker or GraphDriver
- Parameters
name – The name of the GraphWorker.
args – The parameter pack of arguments to pass to the GraphWorker constructor.
- Returns
Expected<void> Success or error code on failure
-
template<typename ...Args>
Expected<void> setDriver(const std::string &name, Args... args) In-place add a GraphDriver Component into Application’s root context, in which case Application’s context should only hold and run GraphWorker or GraphDriver
- Parameters
name – The name of the GraphDriver.
args – The parameter pack of arguments to pass to the GraphDriver constructor.
- Returns
Expected<void> Success or error code on failure
Function to create an application. This function creates a new application with the specified arguments. T is valid application type.
- Returns
shared_ptr of the newly created application object
-
Application()
Segment
-
struct nvidia::gxf::PortPair
A entity - entity connection specified using tx and rx component names tx - transmitter component name rx - receiver component name The queue names should match the parameter keys of the codelet in the corresponding GraphEntity for a successful connection between the two graph entities.
-
SegmentPort source
The source SegmentPort in the connection.
-
SegmentPort target
The target SegmentPort in the connection.
-
PortPair(const SegmentPort &source, const SegmentPort &target)
Constructor for a PortPair with the given source and target SegmentPorts.
-
SegmentPort getSource() const
Returns the source SegmentPort in the connection.
-
SegmentPort getTarget() const
Returns the target SegmentPort in the connection.
-
SegmentPort source
-
struct nvidia::gxf::SegmentPort
An open port in an segment is specified using entity and queue component names. SegmentPort name is in the format “<Entity Name>.<Queue Name>”
Entity Name - name of a graph entity created in the segment Queue Name - tx or rx component name which should match the parameter keys of the codelet in the corresponding GraphEntity for a successful connection
-
std::string name
The name of the SegmentPort, which is a concatenation of the entity name and queue name.
-
std::string entity_name
The name of the entity associated with the SegmentPort.
-
std::string queue_name
The name of the queue (tx or rx) associated with the SegmentPort.
-
std::string name
-
struct SegmentPortPair
A segment - segment connection specified using the segment port info SegmentPort name is in the format “<Entity Name>.<Queue Name>” where the queues are tx or rx components. tx - SegmentPort in the source segment rx - SegmentPort in the sink segment The queue names should match the parameter keys of the codelet in the corresponding GraphEntity for a successful connection between the two segments
-
SegmentPort source
The source SegmentPort in the connection.
-
SegmentPort target
The target SegmentPort in the connection.
-
SegmentPortPair(const SegmentPort &source, const SegmentPort &target)
Constructor for a SegmentPortPair with the given source and target SegmentPorts.
-
SegmentPort getSource() const
Returns the source SegmentPort in the connection.
-
SegmentPort getTarget() const
Returns the target SegmentPort in the connection.
-
SegmentPort source
-
enum nvidia::gxf::SchedulerType
Enum representing the type of scheduler to be used in the application. This enum is primarily used as an input to setScheduler api.
-
enumerator SchedulerType::kGreedy
A single threaded scheduler that assigns resources to entities in a greedy manner, without considering fairness or priorities.
-
enumerator SchedulerType::kMultiThread
A scheduler that uses multiple threads to execute entities concurrently.
-
enumerator SchedulerType::KEventBased
A scheduler that uses an event-based model to schedule entities.
SchedulerType Enumeration Constants
-
constexpr const SchedulerType Greedy = SchedulerType::kGreedy
-
constexpr const SchedulerType MultiThread = SchedulerType::kMultiThread
-
constexpr const SchedulerType EventBased = SchedulerType::KEventBased
-
enumerator SchedulerType::kGreedy
-
class nvidia::gxf::Segment
Segment is a group of graph entities created in a single GXF runtime context. A segment will have its own scheduler. Graph entities in a segment are connected with each other via double buffer transmitter and receiver components. A segment can also be connected other segments via ucx transmitters and receivers. Segments are created and managed by the :cpp:class::nvidia::gxf::Application class.
-
Segment()
Default constructor.
-
virtual ~Segment()
Default Destructor.
-
void compose()
A virtual function that is called to compose the segment. This function is where the entities are created, connected and configured.
-
template<typename CodeletT, typename ...Args>
GraphEntityPtr makeEntity(const char *name, Args... args) Creates a graph entity with a codelet of type CodeletT along with a parameter pack of Arg & ProxyComponent. The codelet component will be used to auto populate connection queues and their corresponding scheduling terms. Args can be used to specify a variable list of components to be created along with the codelet in the graph entity. Args can also be used to specify a variable list of Arg type to update any parameter values of the codelet
- Parameters
const char* name – The name of the graph entity.
Args... args – A parameter pack of Arg or ProxyComponent objects.
- Returns
A newly created graph entity object with the requested components.
-
template<typename ...Args>
GraphEntityPtr makeEntity(const char *name, Args... args) Creates a graph entity without a codelet and with a parameter pack of Arg & ProxyComponent. Args can be used to specify a variable list of components to be created along with the graph entity.
- Parameters
const char* name – The name of the graph entity.
Args... args – A parameter pack of Arg or ProxyComponent objects.
- Returns
A newly created graph entity object with the requested components.
-
template<typename T, typename ...Args>
ProxyComponent makeTerm(const char *name, Args... args) Creates a scheduling term of requested type T and applies parameter component values from a parameter pack of arguments. This api does not create the requested gxf native component. A Proxy component value is returned which has the type info and arg list needed to create this scheduling term. createFromProxy() api is used to create this component given any specific GraphEntity. Type T must be derived from nvidia::gxf::SchedulingTerm type. Args is a parameter pack of arguments / parameter values to be applied to the component.
- Parameters
const char* name – The name of the component.
- Returns
A ProxyComponent object.
-
template<typename T, typename ...Args>
ProxyComponent makeResource(const char *name, Args... args) Creates a resource of requested type and applies parameter component values from a parameter pack of arguments. This api does not create the requested gxf native component. A Proxy component value is returned which has the type info and arg list needed to create this resource. createFromProxy() api is used to create this component given any specific GraphEntity. Type T must be derived from nvidia::gxf::ResourceBase type. Args is a parameter pack of arguments / parameter values to be applied to the component.
- Parameters
const char* name – The name of the component.
- Returns
A ProxyComponent object.
-
template<typename ClockT, typename ...Args>
Handle<Clock> setClock(const char *name, Args... args) Adds a clock component to the segment and applies parameter component values from a parameter pack of arguments. Type T must be derived from nvidia::gxf::Clock type. Args is a parameter pack of arguments / parameter values to be applied to the component.
- Parameters
const char* name – The name of the clock component.
- Returns
Handle<Clock> Handle to newly created clock component. Null handle if component was not created.
-
template<SchedulerType schedulerType, typename ...Args>
Handle<Scheduler> setScheduler(Args... args) Adds a scheduler component to the segment and applies parameter component values from a parameter pack of arguments. Type T must be derived from nvidia::gxf::Scheduler type. Args is a parameter pack of arguments / parameter values to be applied to the component.
- Returns
Handle<Scheduler> Handle to newly created scheduler component. Null handle if component was not created.
-
Handle<Scheduler> setScheduler(const SchedulerType &scheduler, std::vector<Arg> arg_list = {})
Add a scheduler to the segment based on the input SchedulerType enum. If the segment contains a clock component, the same component will be reused to configure the scheduler. If no clock components are found in the segment, a new RealTimeClock component will be added to the segment.
- Parameters
const SchedulerType& scheduler – Type of the scheduler to be added. One of kGreedy, kMultithread or kEventBased.
std::vector<Arg> arg_list – A vector of Arg to apply to the component.
- Returns
A Handle to the newly created scheduler component.
-
Expected<void> connect(GraphEntityPtr &source, GraphEntityPtr &target)
Adds a double buffer queue based connection between two entities with 1:1 tx and rx connectivity.
- Parameters
GraphEntityPtr& source – The origin graph entity for the connection.
GraphEntityPtr& target – The destination graph entity for the connection.
- Returns
Expected<void> Success or error code on failure
-
Expected<void> connect(GraphEntityPtr &source, GraphEntityPtr &target, PortPair port_pair)
Adds a single double buffer queue based connection between two entities with a port pair specified.
- Parameters
GraphEntityPtr& source – The origin graph entity for the connection.
GraphEntityPtr& target – The destination graph entity for the connection.
PortPair port_pair – The port pair containing information of the connection to be created.
- Returns
Expected<void> Success or error code on failure
-
Expected<void> nvidia::gxf::Segment::connect(GraphEntityPtr &source, GraphEntityPtr &target, std::vector<PortPair> port_pairs)
Adds multiple double buffer queue based connections between two entities with many : many tx and rx. Connections between two graph entities are created sequentially.
- Parameters
GraphEntityPtr& source – The origin graph entity for the connection.
GraphEntityPtr& target – The destination graph entity for the connection.
std::vector<PortPair> port_pairs – The list of port pairs containing information of the connections to be created.
- Returns
Expected<void> Success or error code on failure
-
const char *name() const
Fetch the name of the segment.
- Returns
The name of the segment as a const char*.
-
gxf_context_t context()
Fetch the context of a segment.
- Returns
The context of the segment as a gxf_context_t.
-
Expected<void> activate()
Activates all the graph entities in the segment.
- Returns
Expected<void> Success or error code on failure
-
Expected<void> deactivate()
Deactivates all the graph entities in the segment.
- Returns
Expected<void> Success or error code on failure
-
Expected<void> run()
A blocking api to run the segment. This thread is blocked (sleeping) until the segment execution is complete.
- Returns
Expected<void> Success or error code on failure
-
Expected<void> runAsync()
A non blocking api to execute a segment. API returns immediately after starting the segment execution. wait() can be used to wait until execution has finished.
- Returns
Expected<void> Success or error code on failure
-
Expected<void> interrupt()
A non blocking api to stop a previously running segment. Segment is not guaranteed to have stopped when this api returns. wait() can be used to wait until the execution has finished.
- Returns
Expected<void> Success or error code on failure
-
Expected<void> wait()
A blocking API to wait until the segment execution has completed.
- Returns
Expected<void> Success or error code on failure
-
gxf_result_t setSeverity(gxf_severity_t severity)
Sets the severity level of the logs (corresponding to GXF_LOG* logging macros) for a segment
- Parameters
gxf_severity_t severity – A valid severity level as defined in gxf_severity_t. Logs corresponding to any level <= severity will be logged.
- Returns
gxf_result_t On success the function returns GXF_SUCCESS.
-
Expected<void> saveToFile(const char *filepath)
Saves the segment information containing entities, components and their corresponding parameter values in a yaml representation.
- Parameters
const char* filepath – path to save the resulting graph yaml file
- Returns
Expected<void> Success or error code on failure
-
Expected<void> loadParameterFile(const char *filepath)
Loads parameters for graph entities composed in the segment / application. YAML file follows the GXF graph specification.
- Parameters
const char* filepath – path to a valid parameters file
- Returns
Expected<void> Success or error code on failure
-
Expected<void> createNetworkContext()
Creates a Network Context in the segment which can be used by UCX Connections added in the application. A new graph entity with the name “NetworkContext” will be added to the segment context with a UcxContext component and a corresponding entity and component serializers
- Returns
Expected<void> Success or error code on failure
-
Handle<Component> createFromProxy(ProxyComponent &component, GraphEntityPtr &entity)
Creates a component in graph entity based on the type information from the ProxyComponent
- Parameters
ProxyComponent& component – A proxy component object
GraphEntityPtr& entity – A pointer to graph entity to be used for creating the component
- Returns
Handle<Component> Handle to newly created component or null handle on failure
- This function is expected to be called by the application layer to assign a context to the segment and a runtime extension for on
the fly registration of components
- Parameters
gxf_context_t segment_context – A valid GXF context to be assigned to the segment
const char* name – A valid name for the segment
std::shared_ptr<DefaultExtension> runtime_ext – Pointer to a GXF extension which can be used to register any components at runtime
- Returns
Expected<void> Success or error code on failure
-
Segment()
Graph Entity
-
class nvidia::gxf::GraphEntity
A wrapper over nvidia::gxf::Entity to manage a programmable graph entity.
-
Expected<void> nvidia::gxf::GraphEntity::setup(gxf_context_t context, const char *name)
Creates a programmable entity with the runtime context and sets its name.
- Parameters
context – A valid GXF context
name – Name of the graph entity
- Returns
Expected<void> Success or error code on failure
-
template<typename T, typename ...Args>
Handle<T> nvidia::gxf::GraphEntity::add(const char *name = nullptr, Args... args) Creates a generic component of type T and sets the parameter values from Args pack of args. Transmitters, Receivers, Clocks and Scheduling Term component names have to be unique. Type T must be derived from nvidia::gxf::Component.
- Parameters
name – Name of the component
args – Args must be of type Arg
- Returns
Handle<T> Handle to newly created component. Null handle if component was not created.
-
template<typename T>
Handle<T> nvidia::gxf::GraphEntity::add(const char *name, std::vector<Arg> arg_list) Creates a generic component of type T and sets the parameter values from arg_list. Transmitters, Receivers, Clocks and Scheduling Term component names have to be unique. Type T must be derived from nvidia::gxf::Component
- Parameters
name – Name of the component
arg_list – vector of Arg used for initializing the component’s parameters.
- Returns
Handle<T> Handle to newly created component. Null handle if component was not created.
-
template<typename T, size_t N = kMaxComponents>
FixedVector<Handle<T>, N> nvidia::gxf::GraphEntity::findAll() const Finds all components of given type. Returns an empty vector if component is not found. Type T is a type of component to search for.
- Parameters
N – Maximum number of components to return
- Returns
FixedVector<Handle<T>, N> List of handles to components of the same type
-
template<typename T>
Handle<T> nvidia::gxf::GraphEntity::get(const char *name = nullptr) const Gets a component by type and name. Returns null handle if no such component. Type T is a type of component to search for.
- Parameters
name – Name of the component to look for
- Returns
Handle<T> Handle to component, if component is found. Null handle if no such component.
-
template<typename T>
Expected<Handle<T>> nvidia::gxf::GraphEntity::try_get(const char *name = nullptr) const Get a component by type and name. Returns an Unexpected in the case that the component is not found. Unlike get no error is logged if a component is not found. Type T is a type of component to search for.
- Parameters
name – Name of the component to look for
- Returns
Expected<Handle<Component>> Handle to the component, if component is found. Otherwise, an Unexpected is returned.
-
Handle<Component> nvidia::gxf::GraphEntity::get(const char *type_name, const char *name = nullptr) const
Gets a component by type and name. Returns null handle if no such component.
- Parameters
type_name – Fully qualified C++ type name of the component to search for
name – Name of the component to look for
- Returns
Handle<Component> Handle to component, if component is found. Null handle if no such component.
-
template<typename T>
Expected<Handle<T>> nvidia::gxf::GraphEntity::try_get(const char *type_name, const char *name = nullptr) const Get a component by type and name. Returns an Unexpected in the case that the component is not found. Unlike get no error is logged if a component is not found. Type T is a type of component to search for.
- Parameters
type_name – Fully qualified C++ type name of the component to search for
name – Name of the component to look for
- Returns
Expected<Handle<Component>> Handle to the component, if component is found. Otherwise, an Unexpected is returned.
-
template<typename T, typename ...Args>
Handle<T> nvidia::gxf::GraphEntity::addCodelet(const char *name = nullptr, Args... args) Adds a codelet of type T with given name and sets the parameter values from Args. T must be derived from nvidia::gxf::Codelet.
- Parameters
name – Name of the codelet
args – Args must be of type Arg
- Returns
Handle<T> Handle to newly created codelet. Null handle if component was not created.
-
Handle<Codelet> nvidia::gxf::GraphEntity::addCodelet(const char *type_name, const char *name = nullptr, const std::vector<Arg> &arg_list = {})
Adds a codelet with a given C++ type name.
- Parameters
type_name – The fully qualified C++ type name of the codelet component
name – Name of the codelet
arg_list – Arguments for the codelet
- Returns
Handle<Codelet> Handle to newly created codelet component. Null handle if component was not created.
-
Handle<Component> nvidia::gxf::GraphEntity::addComponent(const char *type_name, const char *name = nullptr, const std::vector<Arg> &arg_list = {})
Adds a component with a given C++ type name.
- Parameters
type_name – The fully qualified C++ type name of the component
name – Name of the component
arg_list – Arguments for the component
- Returns
Handle<Component> Handle to newly created component. Null handle if component was not created.
-
template<typename T, typename ...Args>
Handle<T> nvidia::gxf::GraphEntity::addClock(const char *name = nullptr, Args... args) Adds a component of Clock type T and sets the parameter values from Args. T must be derived from nvidia::gxf::Clock
- Parameters
name – Name of the clock
args – Args must be of type Arg
- Returns
Handle<T> Handle to newly created clock component. Null handle if component was not created.
-
Handle<Clock> nvidia::gxf::GraphEntity::addClock(const char *type_name, const char *name = nullptr, const std::vector<Arg> &arg_list = {})
Adds a clock component with a given C++ type name.
- Parameters
type_name – The fully qualified C++ type name of the clock
name – Name of the clock
arg_list – Arguments for the clock component
- Returns
Handle<Clock> Handle to newly created clock
-
Handle<Clock> nvidia::gxf::GraphEntity::getClock(const char *name = nullptr)
Get the Clock object from a graph entity. Returns null handle if no clock component has been created yet. Returns the first clock if no component name is provided. If name is provided, exact instance of the clock is returned if found else a Null handle.
- Parameters
name – Name of the clock component to lookup
- Returns
Handle<Clock>
-
template<typename T, typename ...Args>
Handle<T> nvidia::gxf::GraphEntity::addSchedulingTerm(const char *name = nullptr, Args... args) Adds a component of SchedulingTerm type T and sets the parameter values from Args. T must be derived from nvidia::gxf::SchedulingTerm.
- Parameters
name – name of the scheduling term
args – Args must be of type Arg
- Returns
Handle<T> Handle to newly created scheduling term component
-
Handle<SchedulingTerm> nvidia::gxf::GraphEntity::addSchedulingTerm(const char *type_name, const char *name = nullptr, const std::vector<Arg> &arg_list = {})
Adds a scheduling term component with a given C++ type name.
- Parameters
type_name – The fully qualified C++ type name of the scheduling term
name – Name of the scheduling term
arg_list – Arguments for the scheduling term component
- Returns
Handle<SchedulingTerm> Handle to newly created scheduling term
-
template<typename T, typename ...Args>
Handle<T> nvidia::gxf::GraphEntity::addTransmitter(const char *name, bool omit_term = false, Args... args) Adds a component of Transmitter type T with name and sets the parameter values from Args.
Name of the transmitter should match the parameter name of the underlying codelet. The name of the transmitter component is updated based on the parameter rank info. A Downstream receptive scheduling term is also added to monitor the transmitter component.
If codelet parameter is a scalar, name of the transmitter is also same as the parameter key. Parameter<Handle<Transmitter>> | name - “key”
If codelet parameter is a vector/array, the name of the transmitter component is key_%d where ‘d’ is the index of this transmitter in the codelet parameter. Parameter<Vector<Handle<Transmitter>> | name - “key_0”, “key_1”, “key_2”
Type T must be derived from nvidia::gxf::Transmitter.
- Parameters
name – Name of the transmitter component
omit_term – Boolean flag controlling whether or not a default downstream receptive scheduling term is added. If true, no scheduling term is added.
args – Args must be of type Arg
- Returns
Handle<T> Handle to newly created transmitter component
-
Handle<Transmitter> nvidia::gxf::GraphEntity::addTransmitter(const char *type_name, const char *name = nullptr, const std::vector<Arg> &arg_list = {}, bool omit_term = false)
Adds a component of Transmitter of the corresponding type_name.
Name of the transmitter should match the parameter name of the underlying codelet. The name of the transmitter component is updated based on the parameter rank info. A Downstream receptive scheduling term is also added to monitor the transmitter component.
If codelet parameter is a scalar, name of the transmitter is also same as the parameter key. Parameter<Handle<Transmitter>> | name - “key”
If codelet parameter is a vector/array, the name of the transmitter component is key_%d where ‘d’ is the index of this transmitter in the codelet parameter. Parameter<Vector<Handle<Transmitter>> | name - “key_0”, “key_1”, “key_2”
- Parameters
type_name – The fully qualified C++ type name of the transmitter component
name – Name of the transmitter component
arg_list – Arguments for the transmitter component
omit_term – Boolean flag controlling whether or not a default downstream receptive scheduling term is added. If true, no scheduling term is added.
- Returns
Handle<Transmitter> Handle to newly created transmitter component
-
Handle<Transmitter> nvidia::gxf::GraphEntity::getTransmitter(const char *name)
Receiver component lookup using name
- Parameters
name – name of a transmitter component which has been previously created
- Returns
Handle<Transmitter> Handle to transmitter component if found, Null handle if no such component.
-
template<typename T, typename ...Args>
Handle<T> nvidia::gxf::GraphEntity::addReceiver(const char *name, bool omit_term = false, Args... args) Adds a component of Receiver type T with name and sets the parameter values from Args.
Name of the receiver should match the parameter name of the underlying codelet. The name of the receiver component is updated based on the parameter rank info. A Message available scheduling term is also added to monitor the receiver component.
If codelet parameter is a scalar, name of the receiver is also same as the parameter key. Parameter<Handle<Receiver>> | name - “key”
If codelet parameter is a vector/array, the name of the receiver component is key_%d where ‘d’ is the index of this receiver in the codelet parameter. Parameter<Vector<Handle<Receiver>> | name - “
Type T must be derived from nvidia::gxf::Receiver.
- Parameters
name – Name of the receiver component.
omit_term – Boolean flag controlling whether or not a default message available scheduling term is added. If true, no scheduling term is added.
args – Args must be of type Arg
- Returns
Handle<T> Handle to newly created receiver component
-
Handle<Receiver> addReceiver(const char *type_name, const char *name = nullptr, const std::vector<Arg> &arg_list = {}, bool omit_term = false)
Adds a component of Receiver of the corresponding type_name.
Name of the receiver should match the parameter name of the underlying codelet. The name of the receiver component is updated based on the parameter rank info.
If codelet parameter is a scalar, name of the receiver is also same as the parameter key Parameter<Handle<Receiver>> | name - “key”
If codelet parameter is a vector/array, the name of the receiver component is key_%d where ‘d’ is the index of this receiver in the codelet parameter. Parameter<Vector<Handle<Receiver>> | name - “key_0”, “key_1”, “key_2”
- Parameters
type_name – The fully qualified C++ type name of the receiver.
name – Name of the receiver. Default is nullptr.
arg_list – Arguments for the receiver component. Default is an empty vector.
omit_term – Boolean flag controlling whether or not a default message available scheduling term is added. If true, no scheduling term is added.
- Returns
Handle<Receiver> Handle to newly created receiver component.
-
Handle<Receiver> getReceiver(const char *name)
Receiver component lookup using name
- Parameters
name – name of a receiver component which has been previously created
- Returns
Handle to the receiver component if found, Null handle if no such component.
-
Expected<void> configTransmitter(const char *name, uint64_t capacity, uint64_t policy, uint64_t min_size)
Update the capacity and min_size parameter of a transmitter and its corresponding downstream receptive scheduling term
- Parameters
name – Name of the transmitter component
capacity – capacity of the transmitter to be set
policy – policy of the transmitter to be set
min_size – min size of the downstream receptive term to be set
- Returns
Expected<void> Success or error code on failure
-
Expected<void> configReceiver(const char *name, uint64_t capacity, uint64_t policy, uint64_t min_size)
Update the capacity and min_size parameter of a receiver and its corresponding message available scheduling term
- Parameters
name – Name of the receiver component
capacity – capacity of the receiver to be set
policy – policy of the receiver to be set
min_size – min size of the message available term to be set
- Returns
Expected<void> Success or error code on failure
-
Expected<void> activate()
Activate the GraphEntity
- Returns
Expected<void> Success or error code on failure
-
Expected<void> deactivate()
Deactivate the GraphEntity
- Returns
Expected<void> Success or error code on failure
-
gxf_context_t context() const
Get the context of the GraphEntity
- Returns
gxf_context_t The context of the GraphEntity
-
gxf_uid_t eid() const
Get the entity ID of the GraphEntity
- Returns
gxf_uid_t The entity ID of the GraphEntity
-
bool is_null() const
Check if the GraphEntity is null
- Returns
bool True if the GraphEntity is null, false otherwise
-
Handle<Codelet> get_codelet()
Get the Codelet associated with the GraphEntity
- Returns
Handle<Codelet> The Codelet associated with the GraphEntity, or Null handle if none is set.
-
const char *name() const
Get the name of the entity or an empty string if no name has been given to the entity.
- Returns
const char* A pointer to the name of the entity.
-
Expected<std::string> formatTxName(const char *tx_name)
Given a name for a transmitter to be connected to the codelet, return a formatted string back which can be used for a new transmitter component creation. If the codelet’s tx parameter is a scalar, the tx name is the same as the parameter key. If the codelet’s tx parameter is a vector, the tx name would be “key_0”, “key_1” …
- Parameters
tx_name – name of transmitter component
- Returns
Expected<std::string> formatted name of transmitter component
-
Expected<std::string> formatRxName(const char *rx_name)
Given a name for a receiver to be connected to the codelet, return a formatted string back which can be used for a new receiver component creation. If the codelet’s rx parameter is a scalar, the rx name is the same as the parameter key. If the codelet’s rx parameter is a vector, the rx name would be “key_0”, “key_1” …
- Parameters
rx_name – name of receiver component
- Returns
Expected<std::string> formatted name of receiver component
-
Expected<void> nvidia::gxf::GraphEntity::setup(gxf_context_t context, const char *name)