> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.nvidia.com/holoscan/sdk-user-guide/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.nvidia.com/holoscan/sdk-user-guide/_mcp/server.

# holoscan::EventBasedScheduler

> Event-based scheduler.

Event-based scheduler.

This is a multi-thread scheduler that uses an event-based design. Unlike the [`MultiThreadScheduler`](multithreadscheduler), it does not utilize a dedicated polling thread that is constantly polling operators to check which are ready to execute. Instead, certain events in the underlying framework will indicate that the scheduling status of an operator should be checked.

\==Parameters==

* **worker\_thread\_number** (int64\_t): The number of (CPU) worker threads to use for executing operators. Defaults to 1. This creates a default thread pool. Operators not explicitly assigned to a user-defined thread pool (via make\_thread\_pool) will use this default pool.
* **pin\_cores** (list of int, optional): CPU core IDs to pin the default thread pool's worker threads to (empty means no core pinning). Note: This only affects the default pool; to control CPU affinity for user-defined thread pools, use the pin\_cores parameter in ThreadPool::add().
* **stop\_on\_deadlock** (bool): If True, the application will terminate if a deadlock state is reached. Defaults to true.
* **stop\_on\_deadlock\_timeout** (int64\_t): The amount of time (in ms) before an application is considered to be in deadlock. Defaults to 0.
* **max\_duration\_ms** (int64\_t, optional): Terminate the application after the specified duration even if deadlock does not occur. If unspecified, the application can run indefinitely.
* **enable\_queue\_stealing** (bool): If true, default worker threads attempt to steal ready jobs from other default worker queues before blocking on their own queue. Defaults to false.
* **steal\_scan\_limit** (int64\_t): Maximum number of victim queues scanned per steal attempt (0 means scan all queues). Defaults to 0.
* **enable\_worker\_postcheck\_fastpath** (bool): If true, workers perform a fresh checkEntity() after executeEntity() and directly update READY/WAIT\_TIME conditions without routing that entity through the dispatcher. Defaults to false.
* **postcheck\_fallback\_notify\_interval** (int64\_t): When worker postcheck returns a non-ready state, send a periodic dispatcher wake-up every N fallbacks per worker. Set to 0 to only notify when no workers are running. Defaults to 256.
* **postcheck\_fallback\_notify\_min\_workers** (int64\_t): Periodic fallback notify is enabled only when worker\_thread\_number is at least this value. Defaults to 8.
* **postcheck\_fallback\_notify\_min\_period\_ns** (int64\_t): Minimum global time spacing (in nanoseconds) between periodic fallback dispatcher wake-ups. Defaults to 100000.
* **internal\_event\_shard\_count** (int64\_t): Number of internal notification shards used by notifyDispatcher (0 = auto = worker\_thread\_number). Defaults to 0.
* **dispatcher\_internal\_pop\_batch\_size** (int64\_t): Maximum number of internal notifications drained from one shard per dispatcher pop step. Defaults to 32.
* **wait\_state\_shard\_count** (int64\_t): Number of shards used for WAIT\_EVENT and WAIT tracking lists. Defaults to 1.
* **log\_perf\_stats** (bool): If true, logs scheduler instrumentation counters during deinitialize(). Defaults to false.

```cpp showLineNumbers={false}
#include <holoscan/event_based_scheduler.hpp>
```

**Inherits from:** `holoscan::gxf::GXFScheduler` (public)

***

## Constructors

### EventBasedScheduler \[#eventbasedscheduler]

#### Move

inline

explicit

```cpp showLineNumbers={false}
template <typename ArgT,
          typename... ArgsT,
          typename = std::enable_if_t<!std::is_base_of_v<::holoscan::Scheduler, std::decay_t<ArgT>> &&   (std::is_same_v<::holoscan::Arg, std::decay_t<ArgT>> ||   std::is_same_v<::holoscan::ArgList, std::decay_t<ArgT>>)>>
holoscan::EventBasedScheduler::EventBasedScheduler(
    ArgT &&arg,
    ArgsT &&... args
)
```

#### Default

```cpp showLineNumbers={false}
holoscan::EventBasedScheduler::EventBasedScheduler() = default
```

***

## Methods

### gxf\_typename \[#gxftypename]

```cpp showLineNumbers={false}
const char * holoscan::EventBasedScheduler::gxf_typename() const override
```

Get the type name of the GXF scheduler.

The returned string is the type name of the GXF scheduler and is used to create the GXF scheduler.

Example: "nvidia::holoscan::GreedyScheduler"

**Returns:** The type name of the GXF scheduler.

### clock \[#clock]

```cpp showLineNumbers={false}
std::shared_ptr<Clock> holoscan::EventBasedScheduler::clock() override
```

Get the [Clock](clock) used by the scheduler.

**Returns:** The [Clock](clock) used by the scheduler.

### setup \[#setup]

```cpp showLineNumbers={false}
void holoscan::EventBasedScheduler::setup(
    ComponentSpec &spec
) override
```

Define the scheduler specification.

**Parameters**

The reference to the component specification.

### initialize \[#initialize]

```cpp showLineNumbers={false}
void holoscan::EventBasedScheduler::initialize() override
```

Initialize the component.

This method is called only once when the component is created for the first time, and use of light-weight initialization.

### worker\_thread\_number \[#workerthreadnumber]

```cpp showLineNumbers={false}
int64_t holoscan::EventBasedScheduler::worker_thread_number() const
```

### stop\_on\_deadlock \[#stopondeadlock]

```cpp showLineNumbers={false}
bool holoscan::EventBasedScheduler::stop_on_deadlock() const
```

### stop\_on\_deadlock\_timeout \[#stopondeadlocktimeout]

```cpp showLineNumbers={false}
int64_t holoscan::EventBasedScheduler::stop_on_deadlock_timeout() const
```

### network\_connection\_timeout \[#networkconnectiontimeout]

```cpp showLineNumbers={false}
int64_t holoscan::EventBasedScheduler::network_connection_timeout() const
```

### max\_duration\_ms \[#maxdurationms]

```cpp showLineNumbers={false}
int64_t holoscan::EventBasedScheduler::max_duration_ms() const
```

### pin\_cores \[#pincores]

```cpp showLineNumbers={false}
std::vector<uint32_t> holoscan::EventBasedScheduler::pin_cores() const
```

### enable\_queue\_stealing \[#enablequeuestealing]

```cpp showLineNumbers={false}
bool holoscan::EventBasedScheduler::enable_queue_stealing()
```

### steal\_scan\_limit \[#stealscanlimit]

```cpp showLineNumbers={false}
int64_t holoscan::EventBasedScheduler::steal_scan_limit()
```

### enable\_worker\_postcheck\_fastpath \[#enableworkerpostcheckfastpath]

```cpp showLineNumbers={false}
bool holoscan::EventBasedScheduler::enable_worker_postcheck_fastpath()
```

### postcheck\_fallback\_notify\_interval \[#postcheckfallbacknotifyinterval]

```cpp showLineNumbers={false}
int64_t holoscan::EventBasedScheduler::postcheck_fallback_notify_interval()
```

### postcheck\_fallback\_notify\_min\_workers \[#postcheckfallbacknotifyminworkers]

```cpp showLineNumbers={false}
int64_t holoscan::EventBasedScheduler::postcheck_fallback_notify_min_workers()
```

### postcheck\_fallback\_notify\_min\_period\_ns \[#postcheckfallbacknotifyminperiodns]

```cpp showLineNumbers={false}
int64_t holoscan::EventBasedScheduler::postcheck_fallback_notify_min_period_ns()
```

### internal\_event\_shard\_count \[#internaleventshardcount]

```cpp showLineNumbers={false}
int64_t holoscan::EventBasedScheduler::internal_event_shard_count()
```

### dispatcher\_internal\_pop\_batch\_size \[#dispatcherinternalpopbatchsize]

```cpp showLineNumbers={false}
int64_t holoscan::EventBasedScheduler::dispatcher_internal_pop_batch_size()
```

### wait\_state\_shard\_count \[#waitstateshardcount]

```cpp showLineNumbers={false}
int64_t holoscan::EventBasedScheduler::wait_state_shard_count()
```

### log\_perf\_stats \[#logperfstats]

```cpp showLineNumbers={false}
bool holoscan::EventBasedScheduler::log_perf_stats()
```

### get \[#get]

```cpp showLineNumbers={false}
nvidia::gxf::EventBasedScheduler * holoscan::EventBasedScheduler::get() const
```

### gxf\_clock \[#gxfclock]

```cpp showLineNumbers={false}
virtual nvidia::gxf::Clock * holoscan::EventBasedScheduler::gxf_clock()
```

Get the GXF [Clock](../namespaces/gxf/classes/clock) pointer.

**Returns:** The GXF clock pointer used by the scheduler.

### to\_yaml\_node \[#toyamlnode]

```cpp showLineNumbers={false}
YAML::Node holoscan::EventBasedScheduler::to_yaml_node() const override
```

Get a `YAML` representation of the scheduler.

**Returns:** `YAML` node including type, specs, and resources of the scheduler in addition to the base component properties.

### reset\_backend\_objects \[#resetbackendobjects]

```cpp showLineNumbers={false}
void holoscan::EventBasedScheduler::reset_backend_objects() override
```

Reset any backend-specific objects.

### set\_parameters \[#setparameters]

```cpp showLineNumbers={false}
void holoscan::EventBasedScheduler::set_parameters() override
```

Set the parameters based on defaults (sets GXF parameters for GXF operators).

### id \[#id]

#### Mutable

```cpp showLineNumbers={false}
Scheduler & holoscan::Scheduler::id(
    int64_t id
)
```

Set the [Scheduler](scheduler) ID.

**Returns:** The reference to this scheduler.

**Parameters**

The ID of the scheduler.

#### Const

const

```cpp showLineNumbers={false}
int64_t holoscan::ComponentBase::id() const
```

Get the identifier of the component.

By default, the identifier is set to -1. It is set to a valid value when the component is initialized.

With the default executor (GXFExecutor), the identifier is set to the GXF component ID.

**Returns:** The identifier of the component.

### name \[#name]

#### Set the name of the scheduler (1)

```cpp showLineNumbers={false}
Scheduler & holoscan::Scheduler::name(
    const std::string &name
) &
```

Set the name of the scheduler.

**Returns:** The reference to the scheduler.

**Parameters**

The name of the scheduler.

#### Set the name of the scheduler (2)

```cpp showLineNumbers={false}
Scheduler && holoscan::Scheduler::name(
    const std::string &name
) &&
```

Set the name of the scheduler.

**Returns:** The reference to the scheduler.

**Parameters**

The name of the scheduler.

#### Const

const

```cpp showLineNumbers={false}
const std::string & holoscan::ComponentBase::name() const
```

Get the name of the component.

**Returns:** The name of the component.

### fragment \[#fragment]

#### Set the fragment of the scheduler

```cpp showLineNumbers={false}
Scheduler & holoscan::Scheduler::fragment(
    Fragment *fragment
)
```

Set the fragment of the scheduler.

**Returns:** The reference to the scheduler.

**Parameters**

The pointer to the fragment of the scheduler.

#### Get a pointer to \[Fragment]\(fragment) object

```cpp showLineNumbers={false}
Fragment * holoscan::ComponentBase::fragment()
```

Get a pointer to [Fragment](fragment) object.

**Returns:** The Pointer to [Fragment](fragment) object.

#### Const

const

```cpp showLineNumbers={false}
const Fragment * holoscan::ComponentBase::fragment() const
```

Get a const pointer to [Fragment](fragment) object.

**Returns:** The const pointer to [Fragment](fragment) object.

### spec \[#spec]

#### Set the component specification to the scheduler

```cpp showLineNumbers={false}
Scheduler & holoscan::Scheduler::spec(
    const std::shared_ptr<ComponentSpec> &spec
)
```

Set the component specification to the scheduler.

**Returns:** The reference to the scheduler.

**Parameters**

The component specification.

#### Get the component specification of the scheduler

```cpp showLineNumbers={false}
ComponentSpec * holoscan::Scheduler::spec()
```

Get the component specification of the scheduler.

**Returns:** The pointer to the component specification.

### spec\_shared \[#specshared]

```cpp showLineNumbers={false}
std::shared_ptr<ComponentSpec> holoscan::Scheduler::spec_shared()
```

Get the shared pointer to the component spec.

**Returns:** The shared pointer to the component spec.

### add\_arg \[#addarg]

#### Add a resource to the scheduler (1)

```cpp showLineNumbers={false}
void holoscan::Scheduler::add_arg(
    const std::shared_ptr<Resource> &arg
)
```

Add a resource to the scheduler.

**Parameters**

The resource to add.

#### Add a resource to the scheduler (2)

```cpp showLineNumbers={false}
void holoscan::Scheduler::add_arg(
    std::shared_ptr<Resource> &&arg
)
```

Add a resource to the scheduler.

**Parameters**

The resource to add.

#### Add an argument to the component (1)

```cpp showLineNumbers={false}
void holoscan::ComponentBase::add_arg(
    const Arg &arg
)
```

Add an argument to the component.

**Parameters**

The argument to add.

#### Add an argument to the component (2)

```cpp showLineNumbers={false}
void holoscan::ComponentBase::add_arg(
    Arg &&arg
)
```

Add an argument to the component.

**Parameters**

The argument to add.

#### Add a list of arguments to the component (1)

```cpp showLineNumbers={false}
void holoscan::ComponentBase::add_arg(
    const ArgList &arg
)
```

Add a list of arguments to the component.

**Parameters**

The list of arguments to add.

#### Add a list of arguments to the component (2)

```cpp showLineNumbers={false}
void holoscan::ComponentBase::add_arg(
    ArgList &&arg
)
```

Add a list of arguments to the component.

**Parameters**

The list of arguments to add.

### resources \[#resources]

```cpp showLineNumbers={false}
std::unordered_map<std::string, std::shared_ptr<Resource>> & holoscan::Scheduler::resources()
```

Get the resources of the scheduler.

**Returns:** The resources of the scheduler.

### args \[#args]

```cpp showLineNumbers={false}
std::vector<Arg> & holoscan::ComponentBase::args()
```

Get the list of arguments.

**Returns:** The vector of arguments.

### description \[#description]

```cpp showLineNumbers={false}
std::string holoscan::ComponentBase::description() const
```

Get a description of the component.

**Returns:** `YAML` string.

**See also:**
to\_yaml\_node()

### service \[#service]

```cpp showLineNumbers={false}
template <typename ServiceT = DefaultFragmentService>
std::shared_ptr<ServiceT> holoscan::ComponentBase::service(
    std::string_view id = ""
) const
```

Retrieve a registered fragment service or resource.

Retrieves a previously registered fragment service or resource by its type and optional identifier. Returns nullptr if no service/resource is found with the specified type and identifier.

Note that any changes to the service retrieval logic in this method should be synchronized with the implementation in `Fragment::service()` method to maintain consistency.

**Returns:** The shared pointer to the service/resource, or nullptr if not found or if type casting fails.

**Template parameters**

The type of the service/resource to retrieve. Must inherit from either [Resource](resource) or [FragmentService](fragmentservice). Defaults to [DefaultFragmentService](defaultfragmentservice) if not specified.

**Parameters**

The identifier of the service/resource. If empty, retrieves by type only.

### get\_service\_by\_type\_info \[#getservicebytypeinfo]

```cpp showLineNumbers={false}
std::shared_ptr<FragmentService> holoscan::ComponentBase::get_service_by_type_info(
    const std::type_info &service_type,
    std::string_view id = ""
) const
```

Retrieve a registered fragment service or resource for Python bindings.

This is a helper method for Python bindings to retrieve a service by its C++ type info.

**Returns:** The shared pointer to the base service, or nullptr if not found.

**Parameters**

The type info of the service/resource to retrieve.

The identifier of the service/resource. If empty, retrieves by type only.

### gxf\_context \[#gxfcontext]

#### Mutable

```cpp showLineNumbers={false}
void holoscan::gxf::GXFComponent::gxf_context(
    gxf_context_t gxf_context
)
```

#### Const

const

```cpp showLineNumbers={false}
gxf_context_t holoscan::gxf::GXFComponent::gxf_context() const
```

### gxf\_eid \[#gxfeid]

#### Mutable

```cpp showLineNumbers={false}
void holoscan::gxf::GXFComponent::gxf_eid(
    gxf_uid_t gxf_eid
)
```

#### Const

const

```cpp showLineNumbers={false}
gxf_uid_t holoscan::gxf::GXFComponent::gxf_eid() const
```

### gxf\_tid \[#gxftid]

#### Mutable

```cpp showLineNumbers={false}
void holoscan::gxf::GXFComponent::gxf_tid(
    gxf_tid_t gxf_tid
)
```

#### Const

const

```cpp showLineNumbers={false}
gxf_tid_t holoscan::gxf::GXFComponent::gxf_tid() const
```

### gxf\_cid \[#gxfcid]

#### Mutable

```cpp showLineNumbers={false}
void holoscan::gxf::GXFComponent::gxf_cid(
    gxf_uid_t gxf_cid
)
```

#### Const

const

```cpp showLineNumbers={false}
gxf_uid_t holoscan::gxf::GXFComponent::gxf_cid() const
```

### gxf\_cname \[#gxfcname]

#### Overload 1

```cpp showLineNumbers={false}
std::string & holoscan::gxf::GXFComponent::gxf_cname()
```

#### Overload 2

```cpp showLineNumbers={false}
void holoscan::gxf::GXFComponent::gxf_cname(
    const std::string &name
)
```

### gxf\_graph\_entity \[#gxfgraphentity]

#### Overload 1

```cpp showLineNumbers={false}
std::shared_ptr<nvidia::gxf::GraphEntity> holoscan::gxf::GXFComponent::gxf_graph_entity()
```

#### Overload 2

```cpp showLineNumbers={false}
void holoscan::gxf::GXFComponent::gxf_graph_entity(
    std::shared_ptr<nvidia::gxf::GraphEntity> graph_entity
)
```

### gxf\_entity\_group\_name \[#gxfentitygroupname]

```cpp showLineNumbers={false}
std::string holoscan::gxf::GXFComponent::gxf_entity_group_name()
```

The name of the entity group this component belongs to.

### gxf\_entity\_group\_id \[#gxfentitygroupid]

```cpp showLineNumbers={false}
gxf_uid_t holoscan::gxf::GXFComponent::gxf_entity_group_id()
```

The group id of the entity group this component belongs to.

### gxf\_cptr \[#gxfcptr]

```cpp showLineNumbers={false}
void * holoscan::gxf::GXFComponent::gxf_cptr()
```

### gxf\_component \[#gxfcomponent]

```cpp showLineNumbers={false}
nvidia::gxf::Handle<nvidia::gxf::Component> holoscan::gxf::GXFComponent::gxf_component()
```

### gxf\_initialize \[#gxfinitialize]

```cpp showLineNumbers={false}
void holoscan::gxf::GXFComponent::gxf_initialize()
```

### set\_gxf\_parameter \[#setgxfparameter]

```cpp showLineNumbers={false}
void holoscan::gxf::GXFComponent::set_gxf_parameter(
    const std::string &component_name,
    const std::string &key,
    ParameterWrapper &param_wrap
)
```

Set a given parameter on the underlying GXF component.

### reset\_gxf\_graph\_entity \[#resetgxfgraphentity]

```cpp showLineNumbers={false}
void holoscan::gxf::GXFComponent::reset_gxf_graph_entity()
```

### clock\_gxf\_cptr \[#clockgxfcptr]

```cpp showLineNumbers={false}
void * holoscan::EventBasedScheduler::clock_gxf_cptr() const override
```

### update\_params\_from\_args \[#updateparamsfromargs]

#### Update parameters based on the specified arguments

```cpp showLineNumbers={false}
void holoscan::Component::update_params_from_args()
```

Update parameters based on the specified arguments.

#### Update parameters based on the specified arguments (with params)

```cpp showLineNumbers={false}
void holoscan::ComponentBase::update_params_from_args(
    std::unordered_map<std::string, ParameterWrapper> &params
)
```

Update parameters based on the specified arguments.

### service\_provider \[#serviceprovider]

```cpp showLineNumbers={false}
void holoscan::ComponentBase::service_provider(
    FragmentServiceProvider *provider
)
```

Set the service provider that owns this component.

***

## Static methods

### register\_converter \[#registerconverter]

```cpp showLineNumbers={false}
template <typename typeT>
static void holoscan::ComponentBase::register_converter()
```

Register the argument setter for the given type.

If an operator or resource has an argument with a custom type, the argument setter must be registered using this method.

The argument setter is used to set the value of the argument from the `YAML` configuration.

This method can be called in the initialization phase of the operator/resource (e.g., `initialize()`). The example below shows how to register the argument setter for the custom type (`Vec3`):

It is assumed that `YAML::convert<T>::encode` and `YAML::convert<T>::decode` are implemented for the given type. You need to specialize the `YAML::convert<>` template class.

For example, suppose that you had a `Vec3` class with the following members:

You can define the `YAML::convert<Vec3>` as follows in a '.cpp' file:

Please refer to the [yaml-cpp documentation](https://github.com/jbeder/yaml-cpp/wiki/Tutorial#converting-tofrom-native-data-types) for more details.

**Template parameters**

The type of the argument to register.

**Example**

```cpp showLineNumbers={false}
void MyOp::initialize() {
  register_converter<Vec3>();
}
```

**Example**

```cpp showLineNumbers={false}
struct Vec3 {
  // make sure you have overloaded operator==() for the comparison
  double x, y, z;
};
```

**Example**

```cpp showLineNumbers={false}
namespace YAML {
template<>
struct convert<Vec3> {
  static Node encode(const Vec3& rhs) {
    Node node;
    node.push_back(rhs.x);
    node.push_back(rhs.y);
    node.push_back(rhs.z);
    return node;
  }

  static bool decode(const Node& node, Vec3& rhs) {
    if(!node.IsSequence() || node.size() != 3) {
      return false;
    }

    rhs.x = node[0].as<double>();
    rhs.y = node[1].as<double>();
    rhs.z = node[2].as<double>();
    return true;
  }
};
}
```

### register\_argument\_setter \[#registerargumentsetter]

```cpp showLineNumbers={false}
template <typename typeT>
void holoscan::ComponentBase::register_argument_setter()
```

Register the argument setter for the given type.

Please refer to the documentation of `register_converter()` for more details.

**Template parameters**

The type of the argument to register.

***

## Member variables

| Name                                       | Type                                                             | Description                                       |
| ------------------------------------------ | ---------------------------------------------------------------- | ------------------------------------------------- |
| `clock_`                                   | `Parameter< std::shared_ptr< gxf::Clock > >`                     |                                                   |
| `worker_thread_number_`                    | `Parameter< int64_t >`                                           |                                                   |
| `stop_on_deadlock_`                        | `Parameter< bool >`                                              |                                                   |
| `max_duration_ms_`                         | `Parameter< int64_t >`                                           |                                                   |
| `stop_on_deadlock_timeout_`                | `Parameter< int64_t >`                                           |                                                   |
| `network_connection_timeout_`              | `Parameter< int64_t >`                                           |                                                   |
| `pin_cores_`                               | `Parameter< std::vector< uint32_t > >`                           |                                                   |
| `enable_queue_stealing_`                   | `Parameter< bool >`                                              |                                                   |
| `steal_scan_limit_`                        | `Parameter< int64_t >`                                           |                                                   |
| `enable_worker_postcheck_fastpath_`        | `Parameter< bool >`                                              |                                                   |
| `postcheck_fallback_notify_interval_`      | `Parameter< int64_t >`                                           |                                                   |
| `postcheck_fallback_notify_min_workers_`   | `Parameter< int64_t >`                                           |                                                   |
| `postcheck_fallback_notify_min_period_ns_` | `Parameter< int64_t >`                                           |                                                   |
| `internal_event_shard_count_`              | `Parameter< int64_t >`                                           |                                                   |
| `dispatcher_internal_pop_batch_size_`      | `Parameter< int64_t >`                                           |                                                   |
| `wait_state_shard_count_`                  | `Parameter< int64_t >`                                           |                                                   |
| `log_perf_stats_`                          | `Parameter< bool >`                                              |                                                   |
| `resources_`                               | `std::unordered_map< std::string, std::shared_ptr< Resource > >` | The resources used by the scheduler.              |
| `spec_`                                    | `std::shared_ptr< ComponentSpec >`                               | The component specification.                      |
| `id_`                                      | `int64_t`                                                        | The ID of the component.                          |
| `name_`                                    | `std::string`                                                    | Name of the component.                            |
| `fragment_`                                | `Fragment *`                                                     | Pointer to the fragment that owns this component. |
| `args_`                                    | `std::vector< Arg >`                                             | List of arguments.                                |
| `service_provider_`                        | `FragmentServiceProvider *`                                      | Pointer to the service provider.                  |
| `gxf_context_`                             | `gxf_context_t`                                                  |                                                   |
| `gxf_eid_`                                 | `gxf_uid_t`                                                      |                                                   |
| `gxf_tid_`                                 | `gxf_tid_t`                                                      |                                                   |
| `gxf_cid_`                                 | `gxf_uid_t`                                                      |                                                   |
| `gxf_graph_entity_`                        | `std::shared_ptr< nvidia::gxf::GraphEntity >`                    |                                                   |
| `gxf_cname_`                               | `std::string`                                                    |                                                   |
| `gxf_component_`                           | `nvidia::gxf::Handle< nvidia::gxf::Component >`                  |                                                   |
| `gxf_cptr_`                                | `void *`                                                         |                                                   |