GXF App C++ APIs#

Arg#

struct nvidia::gxf::ArgInfo#

保存 Arg 的类型信息。

gxf_parameter_type_t type#

Arg 的类型。

std::string type_name#

Arg 的类型名称。

int32_t rank#

Arg 的秩。

std::array<int32_t, ParameterInfo<int32_t>::kMaxRank> shape#

Arg 的形状。

struct nvidia::gxf::ArgOverride#

用于覆盖各种 Arg 类型的 ArgInfo 的模板结构。

static Expected<void> apply(ArgInfo &info)#

将 ArgOverride 应用于给定的 ArgInfo。

参数:

ArgInfo& info – 要应用覆盖的 ArgInfo。

返回:

Expected<void> 成功或失败时的错误代码

static ExpectedYAML::Node wrap(const T &value)#

将给定的 arg 值包装在 YAML 节点中。

参数:

const T& value – 要包装的值。

返回:

成功时为包含 YAML 节点的 Expected，失败时为包含错误代码的 Unexpected。

以下模板特化已在 arg.hpp 中的 ArgOverride 结构中实现

ArgOverride<T>
ArgOverride<Handle<T>>
ArgOverride<std::vector<T>>
ArgOverride<std::array<T,N>>
ArgOverride<ProxyComponent>

这些特化涵盖了各种参数类型，包括标量类型、句柄、数组、向量和代理组件。

class nvidia::gxf::Arg#

参数接口，用于从应用程序层配置 GXF 组件中的参数。支持来自 :cpp:enum::gxf_parameter_type_t 枚举的所有参数类型。

Arg(const std::string &key)#

具有给定键的参数的构造函数。

template<typename T>
Arg(const std::string &key, const T &value)#

具有给定键和值的参数的构造函数。

Arg(const std::string &key, const char *value)#

具有给定键和字符串字面值的参数的构造函数。

template<typename T>
Arg(
const std::string &key,
const Handle<T> &value,
)#

具有给定键和组件句柄作为值的参数的构造函数。

Arg(const std::string &key, const ProxyComponent &value)#

具有给定键和代理组件的参数的构造函数。

template<typename T, typename = std::enable_if_t<!std::is_lvalue_reference<T>::value>>
Arg(
const std::string &key,
T &&value,
)#

具有给定键和对值的右值引用的参数的构造函数。

template<typename T, typename = std::enable_if_t<!std::is_lvalue_reference<T>::value>>
Arg(
const std::string &key,
Handle<T> &&value,
)#

具有给定键和对组件句柄的右值引用作为值的参数的构造函数。

Arg(const std::string &key, ProxyComponent &&value)#

具有给定键和对代理组件的右值引用的参数的构造函数。

template<typename T, typename = std::enable_if_t<!std::is_same_v<Arg, std::decay_t<T>>>>
Arg &operator=(
const T &value,
)#

具有给定值的参数的赋值运算符。

template<typename T, typename = std::enable_if_t<!std::is_same_v<Arg, std::decay_t<T>>>>
Arg &operator=(
const Handle<T> &value,
)#

具有给定组件句柄作为值的参数的赋值运算符。

Arg &operator=(ProxyComponent &value)#

具有给定代理组件的参数的赋值运算符。

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,
)#

具有给定值的右值引用的参数的移动赋值运算符。

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,
)#

具有给定组件句柄的右值引用作为值的参数的移动赋值运算符。

Arg &&operator=(ProxyComponent &&value)#

具有给定代理组件的右值引用的参数的移动赋值运算符。

template<typename T, typename = std::enable_if_t<IsDefaultConstructible_v<T>>>
T as(
) const#

用于检索参数值作为给定类型的方法。

const gxf_uid_t handle_uid() const#

用于检索参数句柄 UID 的方法。

const gxf_tid_t handle_tid() const#

用于检索参数句柄 TID 的方法。

const char *key() const#

用于检索参数键的方法。

const std::string arg_type_name() const#

用于检索参数类型名称的方法。

const ArgInfo arg_info() const#

用于检索参数的参数信息的方法。

const YAML::Node yaml_node() const#

用于检索参数的 YAML 节点的方法。

const int32_t rank() const#

用于检索参数秩的方法。

const std::array<int32_t, ParameterInfo<int32_t>::kMaxRank> shape(
) const#

用于检索参数形状的方法。

const gxf_parameter_type_t parameter_type() const#

用于检索参数的参数类型的方法。

bool has_value() const#

用于检索参数是否已赋值的方法

std::any value() const#

用于检索 std::any 对象中参数值的方法

参数解析#

template<typename T, typename First, typename ...Rest>
std::vector<T> parseArgsOfType(
const First &first,
const Rest&... rest,
)#

解析传入的参数包，以获取 T 类型的对象

参数:

T – 要从参数包中筛选的参数类型

返回:

std::vector<T> T 类型对象的列表

Expected<void> applyArg(Handle<Component> component, const Arg &arg)#
参数:

  • component – 有效组件的句柄

  • arg – 要应用于组件的 Arg

返回:

Expected<void> 成功或失败时的错误代码

Expected<Arg> findArg(
const std::vector<Arg> &args,
const std::string &key,
const gxf_parameter_type_t type,
)#
参数:

  • args – 输入 Arg 列表

  • key – 要搜索的 Arg 键

  • type – Arg 的参数类型

返回:

Expected<Arg> 如果找到则返回 Arg 对象，失败则返回错误代码

应用 (Application)#

class nvidia::gxf::Application#

表示 GXF 应用的类。此类提供了一种以命令式方式创建和管理 GXF 应用的便捷方法。用户实现了一个虚拟的 compose() API，在其中构建、配置和相互连接应用程序的各个构建块。

Application()#

应用程序的构造函数。此构造函数初始化一个不包含段或实体的应用程序。

~Application()#

应用程序的析构函数。此析构函数清理应用程序分配的任何资源。

Application(const Application&) = delete#

应用程序的复制构造函数。此构造函数已删除，以防止复制应用程序。

Application &operator=(const Application&) = delete#

应用程序的复制赋值运算符。此运算符已删除，以防止复制应用程序。

Application(Application&&) = delete#

应用程序的移动构造函数。此构造函数已删除，以防止移动应用程序。

Application &operator=(Application&&) = delete#

应用程序的移动赋值运算符。此运算符已删除，以防止移动应用程序。

virtual void compose()#

一个虚函数，调用它来组合应用程序。此函数是创建和配置应用程序的段和实体的地方。

Expected<void> setConfig(const std::string &file_path)#

用于设置应用程序配置的函数。此函数通过从文件加载来设置应用程序的配置。

参数:

file_path – 用于段分布式执行的 yaml 配置文件的绝对路径

返回:

Expected<void> 成功或失败时的错误代码

Expected<void> setConfig(int argc, char **argv)#

用于设置应用程序配置的函数。此函数通过从命令行参数解析来设置应用程序的配置。

参数:

  • argc – CLI 参数计数

  • argv – CLI 参数数组，第二个是用于段分布式执行的配置文件路径

返回:

Expected<void> 成功或失败时的错误代码

template<typename SegmentT, typename = std::enable_if_t<!std::is_same_v<Segment, std::decay_t<SegmentT>>>>
std::shared_ptr<SegmentT> createSegment(
const char *name,
)#

用于在应用程序中创建段的函数。此函数在应用程序中创建一个具有指定名称的新段。段的图将在创建后被 compose()。SegmentT 是有效的段类型。

参数:

name – 段的名称

返回:

Expected<void> 成功或失败时的错误代码

Expected<void> loadExtensionManifest(const char *manifest)#

用于加载扩展清单的函数。

参数:

manifest – 包含扩展列表的清单文件的路径

返回:

Expected<void> 成功或失败时的错误代码

Expected<void> connect(
SegmentPtr source,
SegmentPtr target,
std::vector<SegmentPortPair> port_maps,
)#

此函数通过映射端口来连接两个段。它在两个实体之间添加 UCX 连接，并在两个段的源实体和目标实体中添加多个多对多的 tx 和 rx Ucx 发射器和 Ucx 接收器组件。

参数:

  • source – 包含发送消息的实体的段

  • target – 包含接收实体的段。消息可用术语与 Ucx 接收器一起添加

  • port_maps – 段端口映射，包含用于连接的实体和队列名称。

返回:

Expected<void> 成功或失败时的错误代码

gxf_result_t nvidia::gxf::Application::setSegmentSeverity(
const char *name,
gxf_severity_t severity,
)#

为特定段设置日志的严重性级别（对应于 GXF_LOG_* 日志宏）

参数:

  • name – 段的名称。

  • severity – 严重性级别。

返回:

一个 gxf_result_t，指示成功或失败。

Expected<void> run()#

一个阻塞式 API，用于运行图。如果应用程序包含多个段，则每个段都异步启动，并且此线程被阻塞，直到每个段都完成执行。如果图包含多个实体，则此线程被阻塞，直到图执行完成。

返回:

Expected<void> 成功或失败时的错误代码

Expected<void> runAsync()#

一个非阻塞式 API 调用，用于运行应用程序。如果应用程序包含多个段，则每个段都异步启动。

返回:

Expected<void> 成功或失败时的错误代码

Expected<void> interrupt()#

一个非阻塞式 API，用于停止所有正在运行的段或实体。

返回:

Expected<void> 成功或失败时的错误代码

Expected<void> wait()#

一个阻塞式 API，用于等待直到图执行完成

返回:

Expected<void> 成功或失败时的错误代码

template<typename ...Args>
Expected<void> setWorker(
const std::string &name,
Args... args,
)#

在应用程序的根上下文中就地添加 GraphWorker 组件，在这种情况下，应用程序的上下文应仅持有和运行 GraphWorker 或 GraphDriver

参数:

  • name – GraphWorker 的名称。

  • args – 要传递给 GraphWorker 构造函数的参数包。

返回:

Expected<void> 成功或失败时的错误代码

template<typename ...Args>
Expected<void> setDriver(
const std::string &name,
Args... args,
)#

在应用程序的根上下文中就地添加 GraphDriver 组件，在这种情况下，应用程序的上下文应仅持有和运行 GraphWorker 或 GraphDriver

参数:

  • name – GraphDriver 的名称。

  • args – 要传递给 GraphDriver 构造函数的参数包。

返回:

Expected<void> 成功或失败时的错误代码

template<typename T, typename ...Args>
std::shared_ptr<T> create_app<T, Args...>(
Args&&... args,
)#

用于创建应用程序的函数。此函数使用指定的参数创建一个新的应用程序。 T 是有效的应用程序类型。

返回:

新创建的应用程序对象的 shared_ptr

段#

struct nvidia::gxf::PortPair#

使用 tx 和 rx 组件名称指定的实体 - 实体连接 tx - 发射器组件名称 rx - 接收器组件名称。队列名称应与相应 GraphEntity 中代码段的参数键匹配，以便在两个图实体之间成功连接。

SegmentPort source#

连接中的源 SegmentPort。

SegmentPort target#

连接中的目标 SegmentPort。

PortPair(const SegmentPort &source, const SegmentPort &target)#

具有给定源和目标 SegmentPort 的 PortPair 的构造函数。

SegmentPort getSource() const#

返回连接中的源 SegmentPort。

SegmentPort getTarget() const#

返回连接中的目标 SegmentPort。

struct nvidia::gxf::SegmentPort#

段中的开放端口使用实体和队列组件名称指定。SegmentPort 名称的格式为“<实体名称>.<队列名称>”

实体名称 - 在段中创建的图实体的名称 队列名称 - tx 或 rx 组件名称，应与相应 GraphEntity 中代码段的参数键匹配，以便成功连接

std::string name#

SegmentPort 的名称，它是实体名称和队列名称的串联。

std::string entity_name#

与 SegmentPort 关联的实体的名称。

std::string queue_name#

与 SegmentPort 关联的队列（tx 或 rx）的名称。

struct SegmentPortPair#

使用段端口信息指定的段 - 段连接。SegmentPort 名称的格式为“<实体名称>.<队列名称>”，其中队列是 tx 或 rx 组件。 tx - 源段中的 SegmentPort rx - 接收段中的 SegmentPort。队列名称应与相应 GraphEntity 中代码段的参数键匹配，以便在两个段之间成功连接。

SegmentPort source#

连接中的源 SegmentPort。

SegmentPort target#

连接中的目标 SegmentPort。

SegmentPortPair(const SegmentPort &source, const SegmentPort &target)#

具有给定源和目标 SegmentPort 的 SegmentPortPair 的构造函数。

SegmentPort getSource() const#

返回连接中的源 SegmentPort。

SegmentPort getTarget() const#

返回连接中的目标 SegmentPort。

enum nvidia::gxf::SchedulerType#

表示要应用于应用程序的调度器类型的枚举。此枚举主要用作 setScheduler api 的输入。

enumerator SchedulerType::kGreedy#

单线程调度器，它以贪婪的方式将资源分配给实体，而不考虑公平性或优先级。

enumerator SchedulerType::kMultiThread#

一种使用多线程并发执行实体的调度器。

enumerator SchedulerType::KEventBased#

一种使用基于事件的模型来调度实体的调度器。

SchedulerType 枚举常量

constexpr const SchedulerType Greedy = SchedulerType::kGreedy#
constexpr const SchedulerType MultiThread = SchedulerType::kMultiThread#
constexpr const SchedulerType EventBased = SchedulerType::KEventBased#
class nvidia::gxf::Segment#

段是在单个 GXF 运行时上下文中创建的图实体组。一个段将有自己的调度器。段中的图实体通过双缓冲发射器和接收器组件相互连接。段也可以通过 ucx 发射器和接收器连接到其他段。段由 :cpp:class::nvidia::gxf::Application 类创建和管理。

Segment()#

默认构造函数。

virtual ~Segment()#

默认析构函数。

Segment(Segment&&) = default#

默认移动构造函数。

Segment &operator=(Segment&&) = default#

默认移动赋值运算符。

void compose()#

一个虚函数，调用该函数来组合段。此函数是创建、连接和配置实体的位置。

template<typename CodeletT, typename ...Args>
GraphEntityPtr makeEntity(
const char *name,
Args... args,
)#

使用 CodeletT 类型的代码段以及 Arg & ProxyComponent 的参数包创建图实体。代码段组件将用于自动填充连接队列及其相应的调度项。 Args 可用于指定要与图实体中的代码段一起创建的组件的可变列表。 Args 也可用于指定 Arg 类型的可变列表，以更新代码段的任何参数值

参数:

  • const char* name – 图实体的名称。

  • Args... args – Arg 或 ProxyComponent 对象的参数包。

返回:

新创建的具有请求组件的图实体对象。

template<typename ...Args>
GraphEntityPtr makeEntity(
const char *name,
Args... args,
)#

创建没有代码段且具有 Arg & ProxyComponent 参数包的图实体。 Args 可用于指定要与图实体一起创建的组件的可变列表。

参数:

  • const char* name – 图实体的名称。

  • Args... args – Arg 或 ProxyComponent 对象的参数包。

返回:

新创建的具有请求组件的图实体对象。

template<typename T, typename ...Args>
ProxyComponent makeTerm(
const char *name,
Args... args,
)#

创建请求类型 T 的调度项，并从参数包中应用参数组件值。此 api 不会创建请求的 gxf 原生组件。返回一个 Proxy 组件值，该值具有创建此调度项所需的类型信息和参数列表。 createFromProxy() api 用于创建此组件，给定任何特定的 GraphEntity。类型 T 必须派生自 nvidia::gxf::SchedulingTerm 类型。 Args 是要应用于组件的参数/参数值的参数包。

参数:

const char* name – 组件的名称。

返回:

ProxyComponent 对象。

template<typename T, typename ...Args>
ProxyComponent makeResource(
const char *name,
Args... args,
)#

创建请求类型的资源，并从参数包中应用参数组件值。此 api 不会创建请求的 gxf 原生组件。返回一个 Proxy 组件值，该值具有创建此资源所需的类型信息和参数列表。 createFromProxy() api 用于创建此组件，给定任何特定的 GraphEntity。类型 T 必须派生自 nvidia::gxf::ResourceBase 类型。 Args 是要应用于组件的参数/参数值的参数包。

参数:

const char* name – 组件的名称。

返回:

ProxyComponent 对象。

template<typename ClockT, typename ...Args>
Handle<Clock> setClock(
const char *name,
Args... args,
)#

向段添加时钟组件，并从参数包中应用参数组件值。类型 T 必须派生自 nvidia::gxf::Clock 类型。 Args 是要应用于组件的参数/参数值的参数包。

参数:

const char* name – 时钟组件的名称。

返回:

Handle<Clock> 指向新创建的时钟组件的句柄。如果组件未创建，则为空句柄。

template<SchedulerType schedulerType, typename ...Args>
Handle<Scheduler> setScheduler(
Args... args,
)#

向段添加调度器组件，并从参数包中应用参数组件值。类型 T 必须派生自 nvidia::gxf::Scheduler 类型。 Args 是要应用于组件的参数/参数值的参数包。

返回:

Handle<Scheduler> 指向新创建的调度器组件的句柄。如果组件未创建，则为空句柄。

Handle<Scheduler> setScheduler(
const SchedulerType &scheduler,
std::vector<Arg> arg_list = {},
)#

基于输入的 SchedulerType 枚举向段添加调度器。如果段包含时钟组件，则将重用同一组件来配置调度器。如果在段中未找到时钟组件，则将向段添加新的 RealTimeClock 组件。

参数:

  • const SchedulerType& scheduler – 要添加的调度器的类型。 kGreedy、kMultithread 或 kEventBased 之一。

  • std::vector<Arg> arg_list – 要应用于组件的 Arg 向量。

返回:

指向新创建的调度器组件的 Handle。

Expected<void> connect(GraphEntityPtr &source, GraphEntityPtr &target)#

在两个实体之间添加基于双缓冲队列的连接，具有 1:1 的发送 (tx) 和接收 (rx) 连接性。

参数:

  • GraphEntityPtr& source – 连接的源图实体。

  • GraphEntityPtr& target – 连接的目标图实体。

返回:

Expected<void> 成功或失败时的错误代码

Expected<void> connect(
GraphEntityPtr &source,
GraphEntityPtr &target,
PortPair port_pair,
)#

在两个实体之间添加基于单个双缓冲队列的连接，并指定端口对。

参数:

  • GraphEntityPtr& source – 连接的源图实体。

  • GraphEntityPtr& target – 连接的目标图实体。

  • PortPair port_pair – 包含要创建的连接信息的端口对。

返回:

Expected<void> 成功或失败时的错误代码

Expected<void> nvidia::gxf::Segment::connect(
GraphEntityPtr &source,
GraphEntityPtr &target,
std::vector<PortPair> port_pairs,
)#

在两个实体之间添加多个基于双缓冲队列的连接，具有多对多的发送 (tx) 和接收 (rx)。两个图实体之间的连接是顺序创建的。

参数:

  • GraphEntityPtr& source – 连接的源图实体。

  • GraphEntityPtr& target – 连接的目标图实体。

  • std::vector<PortPair> port_pairs – 包含要创建的连接信息的端口对列表。

返回:

Expected<void> 成功或失败时的错误代码

const char *name() const#

获取段的名称。

返回:

段的名称，类型为 const char*。

gxf_context_t context()#

获取段的上下文。

返回:

段的上下文，类型为 gxf_context_t。

Expected<void> activate()#

激活段中的所有图实体。

返回:

Expected<void> 成功或失败时的错误代码

Expected<void> deactivate()#

停用段中的所有图实体。

返回:

Expected<void> 成功或失败时的错误代码

Expected<void> run()#

一个阻塞式 API，用于运行段。此线程将被阻塞（休眠），直到段执行完成。

返回:

Expected<void> 成功或失败时的错误代码

Expected<void> runAsync()#

一个非阻塞式 API，用于执行段。API 在启动段执行后立即返回。可以使用 wait() 等待执行完成。

返回:

Expected<void> 成功或失败时的错误代码

Expected<void> interrupt()#

一个非阻塞式 API，用于停止先前运行的段。不保证此 API 返回时段已停止。可以使用 wait() 等待执行完成。

返回:

Expected<void> 成功或失败时的错误代码

Expected<void> wait()#

一个阻塞式 API，用于等待段执行完成。

返回:

Expected<void> 成功或失败时的错误代码

gxf_result_t setSeverity(gxf_severity_t severity)#

设置段的日志严重级别（对应于 GXF_LOG* 日志宏）

参数:

gxf_severity_t severity – 有效的严重级别，如 gxf_severity_t 中定义。将记录任何级别 <= severity 的日志。

返回:

gxf_result_t 成功时，函数返回 GXF_SUCCESS。

Expected<void> saveToFile(const char *filepath)#

以 YAML 表示形式保存包含实体、组件及其相应参数值的段信息。

参数:

const char* filepath – 保存生成的图 YAML 文件的路径

返回:

Expected<void> 成功或失败时的错误代码

Expected<void> loadParameterFile(const char *filepath)#

加载段/应用程序中组成的图实体的参数。YAML 文件遵循 GXF 图规范。

参数:

const char* filepath – 有效参数文件的路径

返回:

Expected<void> 成功或失败时的错误代码

Expected<void> createNetworkContext()#

在段中创建一个网络上下文，可供应用程序中添加的 UCX 连接使用。名称为 “NetworkContext” 的新图实体将添加到段上下文中，其中包含 UcxContext 组件以及相应的实体和组件序列化器

返回:

Expected<void> 成功或失败时的错误代码

Handle<Component> createFromProxy(
ProxyComponent &component,
GraphEntityPtr &entity,
)#

根据 ProxyComponent 中的类型信息在图实体中创建组件

参数:

  • ProxyComponent& component – 代理组件对象

  • GraphEntityPtr& entity – 用于创建组件的图实体的指针

返回:

Handle<Component> 新创建组件的句柄；失败时为空句柄

Expected<void> setup(
gxf_context_t segment_context,
const char *name,
std::shared_ptr<DefaultExtension> runtime_ext,
)#
应用程序层应调用此函数，以将上下文分配给段，并将运行时扩展用于

组件的即时注册

参数:

  • gxf_context_t segment_context – 要分配给段的有效 GXF 上下文

  • const char* name – 段的有效名称

  • std::shared_ptr<DefaultExtension> runtime_ext – 指向 GXF 扩展的指针，该扩展可用于在运行时注册任何组件

返回:

Expected<void> 成功或失败时的错误代码

Expected<void> setName(const char *name)#

设置段的名称

参数:

const char* name – 段的有效名称

返回:

Expected<void> 成功或失败时的错误代码

图实体#

class nvidia::gxf::GraphEntity#

nvidia::gxf::Entity 的包装器，用于管理可编程图实体。

Expected<void> nvidia::gxf::GraphEntity::setup(
gxf_context_t context,
const char *name,
)#

创建具有运行时上下文的可编程实体，并设置其名称。

参数:

  • context – 有效的 GXF 上下文

  • name – 图实体的名称

返回:

Expected<void> 成功或失败时的错误代码

template<typename T, typename ...Args>
Handle<T> nvidia::gxf::GraphEntity::add(
const char *name = nullptr,
Args... args,
)#

创建类型为 T 的通用组件，并从 Args 参数包中设置参数值。Transmitter、Receiver、Clock 和 Scheduling Term 组件名称必须是唯一的。类型 T 必须派生自 nvidia::gxf::Component。

参数:

  • name – 组件的名称

  • args – Args 必须是 Arg 类型

返回:

Handle<T> 新创建组件的句柄。如果未创建组件，则为空句柄。

template<typename T>
Handle<T> nvidia::gxf::GraphEntity::add(
const char *name,
std::vector<Arg> arg_list,
)#

创建类型为 T 的通用组件，并从 arg_list 中设置参数值。Transmitter、Receiver、Clock 和 Scheduling Term 组件名称必须是唯一的。类型 T 必须派生自 nvidia::gxf::Component

参数:

  • name – 组件的名称

  • arg_list – 用于初始化组件参数的 Arg 向量。

返回:

Handle<T> 新创建组件的句柄。如果未创建组件，则为空句柄。

template<typename T, size_t N = kMaxComponents>
FixedVector<Handle<T>, N> nvidia::gxf::GraphEntity::findAll(
) const#

查找给定类型的全部组件。如果未找到组件，则返回空向量。类型 T 是要搜索的组件的类型。

参数:

N – 要返回的最大组件数量

返回:

FixedVector<Handle<T>, N> 相同类型的组件的句柄列表

template<typename T>
Handle<T> nvidia::gxf::GraphEntity::get(
const char *name = nullptr,
) const#

按类型和名称获取组件。如果不存在此类组件，则返回空句柄。类型 T 是要搜索的组件的类型。

参数:

name – 要查找的组件的名称

返回:

Handle<T> 组件的句柄（如果找到组件）。如果不存在此类组件，则为空句柄。

template<typename T>
Expected<Handle<T>> nvidia::gxf::GraphEntity::try_get(
const char *name = nullptr,
) const#

按类型和名称获取组件。如果未找到组件，则返回 Unexpected。与 get 不同，如果未找到组件，则不会记录错误。类型 T 是要搜索的组件的类型。

参数:

name – 要查找的组件的名称

返回:

Expected<Handle<Component>> 组件的句柄（如果找到组件）。否则，返回 Unexpected。

Handle<Component> nvidia::gxf::GraphEntity::get(
const char *type_name,
const char *name = nullptr,
) const#

按类型和名称获取组件。如果不存在此类组件，则返回空句柄。

参数:

  • type_name – 要搜索的组件的完全限定 C++ 类型名称

  • name – 要查找的组件的名称

返回:

Handle<Component> 组件的句柄（如果找到组件）。如果不存在此类组件，则为空句柄。

template<typename T>
Expected<Handle<T>> nvidia::gxf::GraphEntity::try_get(
const char *type_name,
const char *name = nullptr,
) const#

按类型和名称获取组件。如果未找到组件，则返回 Unexpected。与 get 不同，如果未找到组件，则不会记录错误。类型 T 是要搜索的组件的类型。

参数:

  • type_name – 要搜索的组件的完全限定 C++ 类型名称

  • name – 要查找的组件的名称

返回:

Expected<Handle<Component>> 组件的句柄（如果找到组件）。否则，返回 Unexpected。

template<typename T, typename ...Args>
Handle<T> nvidia::gxf::GraphEntity::addCodelet(
const char *name = nullptr,
Args... args,
)#

添加类型为 T 的 codelet，并给定名称，并从 Args 设置参数值。T 必须派生自 nvidia::gxf::Codelet。

参数:

  • name – Codelet 的名称

  • args – Args 必须是 Arg 类型

返回:

Handle<T> 新创建 codelet 的句柄。如果未创建组件，则为空句柄。

Handle<Codelet> nvidia::gxf::GraphEntity::addCodelet(
const char *type_name,
const char *name = nullptr,
const std::vector<Arg> &arg_list = {},
)#

添加具有给定 C++ 类型名称的 codelet。

参数:

  • type_name – codelet 组件的完全限定 C++ 类型名称

  • name – Codelet 的名称

  • arg_list – codelet 的参数

返回:

Handle<Codelet> 新创建 codelet 组件的句柄。如果未创建组件，则为空句柄。

Handle<Component> nvidia::gxf::GraphEntity::addComponent(
const char *type_name,
const char *name = nullptr,
const std::vector<Arg> &arg_list = {},
)#

添加具有给定 C++ 类型名称的组件。

参数:

  • type_name – 组件的完全限定 C++ 类型名称

  • name – 组件的名称

  • arg_list – 组件的参数

返回:

Handle<Component> 新创建组件的句柄。如果组件未创建，则为空句柄。

template<typename T, typename ...Args>
Handle<T> nvidia::gxf::GraphEntity::addClock(
const char *name = nullptr,
Args... args,
)#

添加时钟类型为 T 的组件，并从 Args 设置参数值。T 必须派生自 nvidia::gxf::Clock。

参数:

  • name – 时钟的名称

  • args – Args 必须是 Arg 类型

返回:

Handle<T> 新创建时钟组件的句柄。如果组件未创建，则为空句柄。

Handle<Clock> nvidia::gxf::GraphEntity::addClock(
const char *type_name,
const char *name = nullptr,
const std::vector<Arg> &arg_list = {},
)#

添加具有给定 C++ 类型名称的时钟组件。

参数:

  • type_name – 时钟的完全限定 C++ 类型名称

  • name – 时钟的名称

  • arg_list – 时钟组件的参数

返回:

Handle<Clock> 新创建时钟的句柄

Handle<Clock> nvidia::gxf::GraphEntity::getClock(
const char *name = nullptr,
)#

从图实体中获取时钟对象。如果尚未创建时钟组件，则返回空句柄。如果未提供组件名称，则返回第一个时钟。如果提供了名称，则找到时返回时钟的精确实例，否则返回空句柄。

参数:

name – 要查找的时钟组件的名称

返回:

Handle<Clock>

template<typename T, typename ...Args>
Handle<T> nvidia::gxf::GraphEntity::addSchedulingTerm(
const char *name = nullptr,
Args... args,
)#

添加调度项类型为 T 的组件，并从 Args 设置参数值。T 必须派生自 nvidia::gxf::SchedulingTerm。

参数:

  • name – 调度项的名称

  • args – Args 必须是 Arg 类型

返回:

Handle<T> 新创建调度项组件的句柄

Handle<SchedulingTerm> nvidia::gxf::GraphEntity::addSchedulingTerm(
const char *type_name,
const char *name = nullptr,
const std::vector<Arg> &arg_list = {},
)#

添加具有给定 C++ 类型名称的调度项组件。

参数:

  • type_name – 调度项的完全限定 C++ 类型名称

  • name – 调度项的名称

  • arg_list – 调度项组件的参数

返回:

Handle<SchedulingTerm> 新创建调度项的句柄

template<typename T, typename ...Args>
Handle<T> nvidia::gxf::GraphEntity::addTransmitter(
const char *name,
bool omit_term = false,
Args... args,
)#

添加名称为 name 且类型为 Transmitter T 的组件，并从 Args 设置参数值。

发射器的名称应与底层代码小程序的参数名称匹配。发射器组件的名称会根据参数秩信息进行更新。还会添加下游接受调度项以监视发射器组件。

如果代码小程序参数是标量，则发射器的名称也与参数键相同。Parameter<Handle<Transmitter>> | name - “key”

如果代码小程序参数是向量/数组，则发射器组件的名称为 key_%d，其中 ‘d’ 是此发射器在代码小程序参数中的索引。Parameter<Vector<Handle<Transmitter>>> | name - “key_0”, “key_1”, “key_2”

类型 T 必须派生自 nvidia::gxf::Transmitter。

参数:

  • name – 发射器组件的名称

  • omit_term – 布尔标志，用于控制是否添加默认的下游接受调度项。如果为 true，则不添加调度项。

  • args – Args 必须是 Arg 类型

返回:

Handle<T> 新创建发射器组件的句柄

Handle<Transmitter> nvidia::gxf::GraphEntity::addTransmitter(
const char *type_name,
const char *name = nullptr,
const std::vector<Arg> &arg_list = {},
bool omit_term = false,
)#

添加具有相应 type_name 的 Transmitter 组件。

发射器的名称应与底层代码小程序的参数名称匹配。发射器组件的名称会根据参数秩信息进行更新。还会添加下游接受调度项以监视发射器组件。

如果代码小程序参数是标量，则发射器的名称也与参数键相同。Parameter<Handle<Transmitter>> | name - “key”

如果代码小程序参数是向量/数组，则发射器组件的名称为 key_%d，其中 ‘d’ 是此发射器在代码小程序参数中的索引。Parameter<Vector<Handle<Transmitter>>> | name - “key_0”, “key_1”, “key_2”

参数:

  • type_name – 发射器组件的完全限定 C++ 类型名称

  • name – 发射器组件的名称

  • arg_list – 发射器组件的参数

  • omit_term – 布尔标志，用于控制是否添加默认的下游接受调度项。如果为 true，则不添加调度项。

返回:

Handle<Transmitter> 新创建发射器组件的句柄

Handle<Transmitter> nvidia::gxf::GraphEntity::getTransmitter(
const char *name,
)#

使用名称查找接收器组件

参数:

name – 先前创建的发射器组件的名称

返回:

Handle<Transmitter> 如果找到发射器组件，则返回其句柄；如果不存在此类组件，则返回空句柄。

template<typename T, typename ...Args>
Handle<T> nvidia::gxf::GraphEntity::addReceiver(
const char *name,
bool omit_term = false,
Args... args,
)#

添加名称为 name 且类型为 Receiver T 的组件，并从 Args 设置参数值。

接收器的名称应与底层代码小程序的参数名称匹配。接收器组件的名称会根据参数秩信息进行更新。还会添加消息可用调度项以监视接收器组件。

如果代码小程序参数是标量，则接收器的名称也与参数键相同。Parameter<Handle<Receiver>> | name - “key”

如果代码小程序参数是向量/数组，则接收器组件的名称为 key_%d，其中 ‘d’ 是此接收器在代码小程序参数中的索引。Parameter<Vector<Handle<Receiver>>> | name - “

类型 T 必须派生自 nvidia::gxf::Receiver。

参数:

  • name – 接收器组件的名称。

  • omit_term – 布尔标志，用于控制是否添加默认的消息可用调度项。如果为 true，则不添加调度项。

  • args – Args 必须是 Arg 类型

返回:

Handle<T> 新创建接收器组件的句柄

Handle<Receiver> addReceiver(
const char *type_name,
const char *name = nullptr,
const std::vector<Arg> &arg_list = {},
bool omit_term = false,
)#

添加具有相应 type_name 的 Receiver 组件。

接收器的名称应与底层代码小程序的参数名称匹配。接收器组件的名称会根据参数秩信息进行更新。

如果代码小程序参数是标量，则接收器的名称也与参数键相同。Parameter<Handle<Receiver>> | name - “key”

如果代码小程序参数是向量/数组，则接收器组件的名称为 key_%d，其中 ‘d’ 是此接收器在代码小程序参数中的索引。Parameter<Vector<Handle<Receiver>>> | name - “key_0”, “key_1”, “key_2”

参数:

  • type_name – 接收器的完全限定 C++ 类型名称。

  • name – 接收器的名称。默认为 nullptr。

  • arg_list – 接收器组件的参数。默认为空向量。

  • omit_term – 布尔标志，用于控制是否添加默认的消息可用调度项。如果为 true，则不添加调度项。

返回:

Handle<Receiver> 新创建接收器组件的句柄。

Handle<Receiver> getReceiver(const char *name)#

使用名称查找接收器组件

参数:

name – 先前创建的接收器组件的名称

返回:

如果找到接收器组件，则返回其句柄；如果不存在此类组件，则返回空句柄。

Expected<void> configTransmitter(
const char *name,
uint64_t capacity,
uint64_t policy,
uint64_t min_size,
)#

更新发射器的容量和 min_size 参数及其对应的下游接受调度项

参数:

  • name – 发射器组件的名称

  • capacity – 要设置的发射器容量

  • policy – 要设置的发射器策略

  • min_size – 要设置的下游接受项的最小大小

返回:

Expected<void> 成功或失败时的错误代码

Expected<void> configReceiver(
const char *name,
uint64_t capacity,
uint64_t policy,
uint64_t min_size,
)#

更新接收器的容量和 min_size 参数及其对应的消息可用调度项

参数:

  • name – 接收器组件的名称

  • capacity – 要设置的接收器容量

  • policy – 要设置的接收器策略

  • min_size – 要设置的消息可用项的最小大小

返回:

Expected<void> 成功或失败时的错误代码

Expected<void> activate()#

激活 GraphEntity

返回:

Expected<void> 成功或失败时的错误代码

Expected<void> deactivate()#

停用 GraphEntity

返回:

Expected<void> 成功或失败时的错误代码

gxf_context_t context() const#

获取 GraphEntity 的上下文

返回:

gxf_context_t GraphEntity 的上下文

gxf_uid_t eid() const#

获取 GraphEntity 的实体 ID

返回:

gxf_uid_t GraphEntity 的实体 ID

bool is_null() const#

检查 GraphEntity 是否为空

返回:

bool 如果 GraphEntity 为空，则为 True；否则为 false

Handle<Codelet> get_codelet()#

获取与 GraphEntity 关联的 Codelet

返回:

Handle<Codelet> 与 GraphEntity 关联的 Codelet；如果未设置，则为空句柄。

const char *name() const#

获取实体的名称；如果实体未命名，则返回空字符串。

返回:

const char* 指向实体名称的指针。

Expected<std::string> formatTxName(const char *tx_name)#

给定要连接到代码小程序的发射器的名称，返回一个格式化的字符串，该字符串可用于创建新的发射器组件。如果代码小程序的 tx 参数是标量，则 tx 名称与参数键相同。如果代码小程序的 tx 参数是向量，则 tx 名称将为 “key_0”、“key_1” …

参数:

tx_name – 发射器组件的名称

返回:

Expected<std::string> 发射器组件的格式化名称

Expected<std::string> formatRxName(const char *rx_name)#

给定要连接到代码小程序的接收器的名称，返回一个格式化的字符串，该字符串可用于创建新的接收器组件。如果代码小程序的 rx 参数是标量，则 rx 名称与参数键相同。如果代码小程序的 rx 参数是向量，则 rx 名称将为 “key_0”、“key_1” …

参数:

rx_name – 接收器组件的名称

返回:

Expected<std::string> 接收器组件的格式化名称

Expected<void> updatePort(const char *key, std::string value)#

使用给定的键和值更新端口。

参数:

  • key – 要更新的端口的键

  • value – 端口的新值

返回:

Expected<void> 成功或失败时的错误代码

本页内容