`. Returns every name that changed, each under the part `second` ([`Rename`](./Rename.md)).
The rest is [`graph::merge`](./index.md#merge)'s ([compose.h](./index.md#compose-h)), the two graphs being the parts `this` and `second`: the shapes, the devices (a connection between two devices moves its value, as under [`CrossDevice::Move`](./index.md#CrossDevice)), the KV caches, the weights and every refusal. On success `second` is consumed (left empty) and this graph is the merged one: a view of `second` then refuses as a view whose graph is gone ([node.h](./index.md#node-h)), and a view of this graph finds its node again by key. On a refusal, or on a failure inside the merge, both are left as they were. Also refuses `InvalidArgument` for a merge of a graph with itself, and `FailedPrecondition` inside one of this graph's transforms ([`optimize`](./ModelGraph.md#optimize)).
Declared in `ClikaRT/graph/model_graph.h`, line 725
### find\_nodes\_by\_name() {#find_nodes_by_name}
`std::vector<`[`Node`](./Node.md)`>` **`find_nodes_by_name`**(
`const` [`regex::Regex`](../regex/Regex.md)`&` `pattern`,
[`NameMatch`](./index.md#NameMatch) `match` `=` [`NameMatch::Whole`](./index.md#NameMatch)
) `const`
Every node whose name `pattern` matches, in name order: the whole name ([`NameMatch::Whole`](./index.md#NameMatch)) or some part of it ([`NameMatch::Anywhere`](./index.md#NameMatch)).
Declared in `ClikaRT/graph/model_graph.h`, line 743
### find\_nodes(NodePredicate) {#find_nodes-2}
`std::vector<`[`Node`](./Node.md)`>` **`find_nodes`**([`NodePredicate`](./index.md#NodePredicate) `predicate`) `const`
Every node `predicate` accepts, in name order. The predicate runs throw-contained: a throw ends the search, which fails with it. Refuses an empty predicate ([`Status::InvalidArgument`](../../index.md#Status)).
Declared in `ClikaRT/graph/model_graph.h`, line 749
### edges() {#edges}
`std::vector<`[`Edge`](./Edge.md)`>` **`edges`**() `const`
Every edge, in (source name, source port, destination name, destination port) order.
Declared in `ClikaRT/graph/model_graph.h`, line 755
### edges\_between() {#edges_between}
`std::vector<`[`Edge`](./Edge.md)`>` **`edges_between`**(`const` [`Node`](./Node.md)`&` `src`, `const` [`Node`](./Node.md)`&` `dst`) `const`
The edges from `src` to `dst`, in (source port, destination port) order. Empty when no edge runs from one to the other, a node of another graph included.
Declared in `ClikaRT/graph/model_graph.h`, line 760
### walk() {#walk}
`std::vector<`[`Node`](./Node.md)`>` **`walk`**(`const` [`Node`](./Node.md)`&` `start`, [`WalkOptions`](./WalkOptions.md) `options` `=` [`WalkOptions`](./WalkOptions.md)`()`) `const`
The nodes a walk from `start` reaches, in walk order: breadth-first, the start first, each node once at its fewest edges from the start, and a node's neighbors in `out_edges()` order (`in_edges()` walking backward). Fails on `options.max_nodes` and with a callable's own failure.
Declared in `ClikaRT/graph/model_graph.h`, line 767
### visit() {#visit}
`void` **`visit`**(
`const` [`Node`](./Node.md)`&` `start`,
[`NodeVisitor`](./index.md#NodeVisitor) `visitor`,
[`WalkOptions`](./WalkOptions.md) `options` `=` [`WalkOptions`](./WalkOptions.md)`()`
) `const`
The same walk, showing `visitor` each node it reaches, the start included: [`VisitAction::Prune`](./index.md#VisitAction) does not go past that node, `Stop` ends the walk, which then succeeds. A throw from the visitor ends the walk, which fails with it. Refuses an empty visitor ([`Status::InvalidArgument`](../../index.md#Status)).
Declared in `ClikaRT/graph/model_graph.h`, line 777
### layers() {#layers}
`std::vector>` **`layers`**() `const`
The topological generations: the nodes with no in-edge first ([`Node::in_degree()`](./Node.md#in_degree) 0), then each node one layer after its latest producer; every layer in [`nodes()`](./ModelGraph.md#nodes) order. Fails like [`nodes()`](./ModelGraph.md#nodes) on a cycle.
Declared in `ClikaRT/graph/model_graph.h`, line 787
### ancestors() {#ancestors}
`std::vector<`[`Node`](./Node.md)`>` **`ancestors`**(`const` [`Node`](./Node.md)`&` `node`, [`WalkOptions`](./WalkOptions.md) `options` `=` [`WalkOptions`](./WalkOptions.md)`()`) `const`
Every node with a path to [`node`](./ModelGraph.md#node), [`node`](./ModelGraph.md#node) left out, nearest first: a backward walk, so `options.direction` is not read.
Declared in `ClikaRT/graph/model_graph.h`, line 792
### descendants() {#descendants}
`std::vector<`[`Node`](./Node.md)`>` **`descendants`**(`const` [`Node`](./Node.md)`&` `node`, [`WalkOptions`](./WalkOptions.md) `options` `=` [`WalkOptions`](./WalkOptions.md)`()`) `const`
Every node with a path from [`node`](./ModelGraph.md#node), [`node`](./ModelGraph.md#node) left out, nearest first: a forward walk, so `options.direction` is not read.
Declared in `ClikaRT/graph/model_graph.h`, line 799
### find\_paths\_to() {#find_paths_to}
`std::vector>` **`find_paths_to`**(
`const` [`Node`](./Node.md)`&` `start`,
[`NodePredicate`](./index.md#NodePredicate) `target`,
[`PathOptions`](./PathOptions.md) `options` `=` [`PathOptions`](./PathOptions.md)`()`
) `const`
Every simple path from `start` that ends at the first node `target` accepts: a path never passes an accepted node, and an accepted `start` is the one-node path. Depth-first, each node's next nodes in `out_edges()` order; parallel edges give one path. The target and the edge filter each run once per node or edge. Fails past [`kMaxPathsWithoutLimit`](./index.md#kMaxPathsWithoutLimit) paths when `options.limit` is empty, and with a callable's own failure. Refuses an empty `target` ([`Status::InvalidArgument`](../../index.md#Status)).
Declared in `ClikaRT/graph/model_graph.h`, line 814
### has\_path() {#has_path}
`bool` **`has_path`**(
`const` [`Node`](./Node.md)`&` `src`,
`const` [`Node`](./Node.md)`&` `dst`,
[`PathOptions`](./PathOptions.md) `options` `=` [`PathOptions`](./PathOptions.md)`()`
) `const`
True when a path runs from `src` to `dst` within `options`; a node reaches itself.
Declared in `ClikaRT/graph/model_graph.h`, line 822
### shortest\_path(Node, Node, PathOptions) {#shortest_path}
`std::vector<`[`Node`](./Node.md)`>` **`shortest_path`**(
`const` [`Node`](./Node.md)`&` `src`,
`const` [`Node`](./Node.md)`&` `dst`,
[`PathOptions`](./PathOptions.md) `options` `=` [`PathOptions`](./PathOptions.md)`()`
) `const`
A path from `src` to `dst` with the fewest edges within `options`, as nodes: `{src}` when the two are one node, empty when no path runs. One answer among equally short paths, the same on every call.
Declared in `ClikaRT/graph/model_graph.h`, line 832
### weighted\_shortest\_path\_impl() {#weighted_shortest_path_impl}
[`Result`](../Result.md)`<`[`WeightedPath`](./WeightedPath.md)`>` **`weighted_shortest_path_impl`**(
`const` [`Node`](./Node.md)`&` `src`,
`const` [`Node`](./Node.md)`&` `dst`,
`detail::ContainedEdgeCost` `edge_cost`,
`const` [`ContainedPathOptions`](./ContainedPathOptions.md)`&` `options`
) `const`
The cheapest path from `src` to `dst` within `options`, `edge_cost` summed over the edges it takes (among parallel edges, the cheapest). Every edge cost must be finite and at least 0; an empty `edge_cost` counts 0. Ties go to fewer edges; under a cutoff, the cheapest path of at most that many edges. Empty when no path runs, `{src}` at cost 0 when the two are one node. `edge_cost` runs at most once per edge. A negative, NaN or infinite cost fails naming the edge ([`Status::InvalidArgument`](../../index.md#Status)); a throw fails with it.
Declared in `ClikaRT/graph/model_graph.h`, line 844
### shortest\_path(Node, Node, EdgeCost, PathOptions) {#shortest_path-2}
[`WeightedPath`](./WeightedPath.md) **`shortest_path`**(
`const` [`Node`](./Node.md)`&` `src`,
`const` [`Node`](./Node.md)`&` `dst`,
[`EdgeCost`](./index.md#EdgeCost) `edge_cost`,
[`PathOptions`](./PathOptions.md) `options` `=` [`PathOptions`](./PathOptions.md)`()`
) `const`
A path from `src` to `dst` with the fewest edges within `options`, as nodes: `{src}` when the two are one node, empty when no path runs. One answer among equally short paths, the same on every call.
Declared in `ClikaRT/graph/model_graph.h`, line 847
### all\_simple\_paths() {#all_simple_paths}
`std::vector>` **`all_simple_paths`**(
`const` [`Node`](./Node.md)`&` `src`,
`const` [`Node`](./Node.md)`&` `dst`,
[`PathOptions`](./PathOptions.md) `options` `=` [`PathOptions`](./PathOptions.md)`()`
) `const`
Every simple path from `src` to `dst`, as nodes; parallel edges give one path (networkx's [`all_simple_paths`](./ModelGraph.md#all_simple_paths) over the graph with parallel edges merged). `src == dst` gives the one-node path. The order, callables and cap of [`find_paths_to`](./ModelGraph.md#find_paths_to).
Declared in `ClikaRT/graph/model_graph.h`, line 859
### all\_simple\_edge\_paths() {#all_simple_edge_paths}
`std::vector>` **`all_simple_edge_paths`**(
`const` [`Node`](./Node.md)`&` `src`,
`const` [`Node`](./Node.md)`&` `dst`,
[`PathOptions`](./PathOptions.md) `options` `=` [`PathOptions`](./PathOptions.md)`()`
) `const`
Every simple path from `src` to `dst`, as edges; each parallel edge gives its own path (networkx's [`all_simple_edge_paths`](./ModelGraph.md#all_simple_edge_paths)). `src == dst` gives one empty path. Depth-first in `out_edges()` order, with the callables and cap of [`find_paths_to`](./ModelGraph.md#find_paths_to).
Declared in `ClikaRT/graph/model_graph.h`, line 870
### count\_paths() {#count_paths}
`std::uint64_t` **`count_paths`**(
`const` [`Node`](./Node.md)`&` `src`,
`const` [`Node`](./Node.md)`&` `dst`,
[`PathOptions`](./PathOptions.md) `options` `=` [`PathOptions`](./PathOptions.md)`()`
) `const`
How many paths [`all_simple_paths`](./ModelGraph.md#all_simple_paths) lists, counted without listing them, so no cap applies and `options.limit` is not read. Fails when the count passes the range of `std::uint64_t`, and like [`nodes()`](./ModelGraph.md#nodes) on a cycle.
Declared in `ClikaRT/graph/model_graph.h`, line 879
### critical\_path() {#critical_path}
[`WeightedPath`](./WeightedPath.md) **`critical_path`**([`NodeCost`](./index.md#NodeCost) `node_cost`, [`EdgeCost`](./index.md#EdgeCost) `edge_cost` `=` [`EdgeCost`](./index.md#EdgeCost)`()`) `const`
The critical path: the path of greatest cost, `node_cost` summed over its nodes and `edge_cost` over its edges, each finite and of any sign; an empty cost counts 0, so two empty costs give the path with the most edges. A path may start and end at any node: a prefix whose sum falls below 0 is dropped and the path starts again at the next node, as networkx's `dag_longest_path` does. Ties go to more edges, then to the path found first. Empty on a graph with no nodes. Each cost runs once per node or edge. A NaN or infinite cost fails naming the node or edge ([`Status::InvalidArgument`](../../index.md#Status)), a throw fails with it, and a cyclic graph fails like [`nodes()`](./ModelGraph.md#nodes).
Declared in `ClikaRT/graph/model_graph.h`, line 894
### topological\_order() {#topological_order}
`std::vector<`[`Node`](./Node.md)`>` **`topological_order`**([`TopologicalOrder`](./index.md#TopologicalOrder) `order` `=` [`TopologicalOrder::Deterministic`](./index.md#TopologicalOrder)) `const`
Every node in the topological order `order` names ([query.h](./index.md#query-h)): each node once, after every node whose output it reads. Fails like [`nodes()`](./ModelGraph.md#nodes) on a cycle.
Declared in `ClikaRT/graph/model_graph.h`, line 903
### random\_topological\_order() {#random_topological_order}
`std::vector<`[`Node`](./Node.md)`>` **`random_topological_order`**(`std::uint64_t` `seed`) `const`
A topological order drawn at random from the valid ones: each node once, after every node whose output it reads. One `seed` draws one order of a given graph, on every platform. Fails like [`nodes()`](./ModelGraph.md#nodes) on a cycle.
Declared in `ClikaRT/graph/model_graph.h`, line 912
### topological\_generations() {#topological_generations}
`std::vector>` **`topological_generations`**() `const`
[`layers()`](./ModelGraph.md#layers) under networkx's name: the same generations from the same call.
Declared in `ClikaRT/graph/model_graph.h`, line 918
### depths() {#depths}
[`NodeMap`](./NodeMap.md)`` **`depths`**() `const`
Each node's generation: the most edges on a path that ends at it, so [`depths()`](./ModelGraph.md#depths)`[n]` is the index of `n`'s layer in [`layers()`](./ModelGraph.md#layers). One entry per node, in [`nodes()`](./ModelGraph.md#nodes) order. Fails like [`nodes()`](./ModelGraph.md#nodes) on a cycle.
Declared in `ClikaRT/graph/model_graph.h`, line 926
### is\_topological\_order() {#is_topological_order}
`bool` **`is_topological_order`**([`ClikaRT::Span`](../Span.md)`` `order`) `const`
True when `order` is a topological order of this graph: every node exactly once, and every edge running forward. A node of another graph, a repeated or a missing node, or an edge running backward makes it false.
Declared in `ClikaRT/graph/model_graph.h`, line 932
### find\_cycle() {#find_cycle}
`std::vector<`[`Edge`](./Edge.md)`>` **`find_cycle`**() `const`
One cycle as its edges, in order: each edge enters the node the next one leaves, and the last enters the node the first one leaves. Empty when the graph has none, as every traced or compiled graph.
Declared in `ClikaRT/graph/model_graph.h`, line 937
### would\_create\_cycle() {#would_create_cycle}
`bool` **`would_create_cycle`**(`const` [`Node`](./Node.md)`&` `src`, `const` [`Node`](./Node.md)`&` `dst`) `const`
True when an edge from `src` to `dst` would close a cycle: `dst` reaches `src`, or the two are one node.
Declared in `ClikaRT/graph/model_graph.h`, line 942
### weakly\_connected\_components() {#weakly_connected_components}
`std::vector>` **`weakly_connected_components`**() `const`
The weakly connected components: the groups of nodes joined by edges taken either way, each in name order, the groups ordered by their first node's name.
Declared in `ClikaRT/graph/model_graph.h`, line 949
### dominators() {#dominators}
[`NodeMap`](./NodeMap.md)`<`[`Node`](./Node.md)`>` **`dominators`**() `const`
Each node's immediate dominator: the last node before it that every path from the graph inputs to it crosses. Paths start at the graph inputs, so a constant or weight operand opens none. A node no other node dominates (an input, or a node where two inputs' paths meet) maps to itself, and a node on no path from an input has no entry. Entries in [`nodes()`](./ModelGraph.md#nodes) order. Fails like [`nodes()`](./ModelGraph.md#nodes) on a cycle.
Declared in `ClikaRT/graph/model_graph.h`, line 958
### post\_dominators() {#post_dominators}
[`NodeMap`](./NodeMap.md)`<`[`Node`](./Node.md)`>` **`post_dominators`**() `const`
Each node's immediate post-dominator: the first node after it that every path from it to the graph outputs crosses. A node no other node post-dominates maps to itself, and a node on no path to an output has no entry. Entries in [`nodes()`](./ModelGraph.md#nodes) order. Fails like [`nodes()`](./ModelGraph.md#nodes) on a cycle.
Declared in `ClikaRT/graph/model_graph.h`, line 965
### split\_points() {#split_points}
`std::vector<`[`Node`](./Node.md)`>` **`split_points`**() `const`
The nodes every path from the graph inputs to the graph outputs crosses, from the inputs to the outputs: where the graph splits into two stages at one node. Empty when no node is on every such path. Fails like [`nodes()`](./ModelGraph.md#nodes) on a cycle.
Declared in `ClikaRT/graph/model_graph.h`, line 972
### lowest\_common\_ancestors() {#lowest_common_ancestors}
`std::vector<`[`Node`](./Node.md)`>` **`lowest_common_ancestors`**([`ClikaRT::Span`](../Span.md)`` `nodes`) `const`
The lowest common ancestors of [`nodes`](./ModelGraph.md#nodes): the nodes every one of them descends from (each counting as its own ancestor) that no other such node descends from, in [`nodes()`](./ModelGraph.md#nodes) order. networkx's `lowest_common_ancestor` returns one of them. At least one node.
Declared in `ClikaRT/graph/model_graph.h`, line 979
### merge\_point() {#merge_point}
`std::optional<`[`Node`](./Node.md)`>` **`merge_point`**([`ClikaRT::Span`](../Span.md)`` `nodes`) `const`
Where the paths from [`nodes`](./ModelGraph.md#nodes) merge: the nearest node every path from them to the graph outputs crosses, each counting for itself. Empty when their paths meet only at the outputs. A node on no path to an output is not counted. At least one node.
Declared in `ClikaRT/graph/model_graph.h`, line 988
### region() {#region}
`std::vector<`[`Node`](./Node.md)`>` **`region`**(`const` [`Node`](./Node.md)`&` `entry`, `const` [`Node`](./Node.md)`&` `exit`) `const`
The single-entry, single-exit region from `entry` to `exit`: the nodes `entry` dominates and `exit` post-dominates, both ends included, in [`nodes()`](./ModelGraph.md#nodes) order; a node alone is a region. Fails ([`Status::InvalidArgument`](../../index.md#Status)) unless `entry` dominates `exit` and `exit` post-dominates `entry`, naming the condition that fails.
Declared in `ClikaRT/graph/model_graph.h`, line 998
### between() {#between}
`std::vector<`[`Node`](./Node.md)`>` **`between`**(`const` [`Node`](./Node.md)`&` `src`, `const` [`Node`](./Node.md)`&` `dst`) `const`
Every node on a path from `src` to `dst`, both ends included, in [`nodes()`](./ModelGraph.md#nodes) order; empty when no path runs.
Declared in `ClikaRT/graph/model_graph.h`, line 1005
### producer\_cone() {#producer_cone}
`std::vector<`[`Node`](./Node.md)`>` **`producer_cone`**([`ClikaRT::Span`](../Span.md)`` `nodes`) `const`
The producer cone of [`nodes`](./ModelGraph.md#nodes): every node whose output they read, directly or through others, in [`nodes()`](./ModelGraph.md#nodes) order. A node of [`nodes`](./ModelGraph.md#nodes) counts only when another one reads it, so the cone of an input is empty.
Declared in `ClikaRT/graph/model_graph.h`, line 1014
### consumer\_cone() {#consumer_cone}
`std::vector<`[`Node`](./Node.md)`>` **`consumer_cone`**([`ClikaRT::Span`](../Span.md)`` `nodes`) `const`
The consumer cone of [`nodes`](./ModelGraph.md#nodes): every node that reads their outputs, directly or through others, in [`nodes()`](./ModelGraph.md#nodes) order; the cone of a node no other node reads is empty.
Declared in `ClikaRT/graph/model_graph.h`, line 1022
### is\_convex() {#is_convex}
`bool` **`is_convex`**([`ClikaRT::Span`](../Span.md)`` `nodes`) `const`
True when [`nodes`](./ModelGraph.md#nodes) is convex: no path leaves the set and comes back into it, so the set can be cut out and replaced as one piece.
Declared in `ClikaRT/graph/model_graph.h`, line 1029
### min\_value\_cut() {#min_value_cut}
[`ValueCut`](./ValueCut.md) **`min_value_cut`**(
[`ClikaRT::Span`](../Span.md)`` `before` `=` `{}`,
[`ClikaRT::Span`](../Span.md)`` `after` `=` `{}`
) `const`
The cheapest cut through the graph's values: a split of the nodes in two, every node before the cut with its producers before it, that hands the fewest bytes from the part before to the part after ([`ValueCut`](./ValueCut.md)). The graph inputs and the nodes of `before` run before the cut and the nodes of `after` after it; a graph output made before the cut is one of the values. A value weighs its tensor's bytes: a view adds nothing to the tensor it re-describes, and a constant or a state buffer is never one of the values. Of the cheapest cuts this is the one nearest the inputs: the least set of nodes before the cut. Fails ([`Status::InvalidArgument`](../../index.md#Status)) when no cut exists, naming the node of `after` that is a graph input, is in `before` or feeds a node of `before`, and ([`Status::Unsupported`](../../index.md#Status)) when a value has no fixed size in bytes (a dynamic dim), since the cut weighs every value.
Declared in `ClikaRT/graph/model_graph.h`, line 1047
### visualize() {#visualize}
`void` **`visualize`**(`std::string_view` `path`) `const`
Write the compiled graph to `path` as an ONNX model for viewing in Netron or any ONNX graph viewer. The file holds the executable topology as [`compile`](./index.md#compile) left it: the runtime's fused and absorbed operators under their own op types, every edge as a tensor wire carrying its shape and dtype, and the graph's inputs and outputs under their names. Structure only. No weights are written, so the file is a picture of the graph, not a runnable model. `path` is created or overwritten.
Declared in `ClikaRT/graph/model_graph.h`, line 1062
### export\_onnx() {#export_onnx}
`void` **`export_onnx`**(`std::string_view` `path`, `const` [`OnnxExportOptions`](./OnnxExportOptions.md)`&` `options` `=` `{}`) `const`
Write the graph to `path` as a runnable ONNX model. The inputs and outputs keep their names, dtypes and dims, and a dynamic dimension is written under its name, so two inputs that share a dimension still share it when the model is read back. The weights become the model's initializers, in the file or beside it as `options` says. They are read as the file is written, one at a time, so the export holds no second copy of them. [`io::OnnxModel::from_graph`](../io/OnnxModel.md#from_graph) builds the same model in memory without writing it; [`io::OnnxModel::open`](../io/OnnxModel.md#open) and [`compile`](./index.md#compile) read the file back.
Refused, with nothing written:
- a graph that rewrites a cache buffer in place: one given a cache by [`attach_kv_cache`](./ModelGraph.md#attach_kv_cache), or one traced over a function that writes its cache in place. Export before [`attach_kv_cache`](./ModelGraph.md#attach_kv_cache), or trace the step with the cache as an input and its update as an output;
- a graph holding an operator that has no ONNX form at the chosen opset, naming the node and the operator;
- a call while [`optimize`](./ModelGraph.md#optimize), [`finalize`](./ModelGraph.md#finalize), [`attach_kv_cache`](./ModelGraph.md#attach_kv_cache), [`to`](./ModelGraph.md#to) or an edit runs on the graph (`FAILED_PRECONDITION`, naming the call).
Declared in `ClikaRT/graph/model_graph.h`, line 1087
### shape\_domains() {#shape_domains}
`std::vector<`[`ShapeDomain`](./ShapeDomain.md)`>` **`shape_domains`**() `const`
The shapes each input admits, [`input_names()`](./ModelGraph.md#input_names) order. A dimension with a fixed size is `Fixed`; a dynamic dimension compiled with a recorded profile (an ONNX compile given `InputSpec` ranges or named-dim bindings) is `Range`; a dynamic dimension without one is `Free`. See [`ShapeDomain`](./ShapeDomain.md) ([bench.h](./index.md#bench-h)).
Declared in `ClikaRT/graph/model_graph.h`, line 1098
### input\_shape\_domain() {#input_shape_domain}
[`ShapeDomain`](./ShapeDomain.md) **`input_shape_domain`**(`std::string_view` `name`) `const`
The domain of the input named `name`. Raises [`ClikaRT::Error`](../Error.md) (NotFound) when no input carries the name.
Declared in `ClikaRT/graph/model_graph.h`, line 1105
### validate\_shapes(vector\) {#validate_shapes}
`void` **`validate_shapes`**(`const std::vector<`[`InputShape`](./InputShape.md)`>&` `shapes`) `const`
Check named shapes against the domains: every runtime input present once, every name an input, every rank equal to the input's, and every extent admitted ([`DimDomain::admits`](./DimDomain.md#admits)). Raises [`ClikaRT::Error`](../Error.md) (InvalidArgument) naming the input and the dimension that failed.
Declared in `ClikaRT/graph/model_graph.h`, line 1114
### validate\_shapes(vector\\>) {#validate_shapes-2}
`void` **`validate_shapes`**(`const std::vector>&` `shapes`) `const`
Check named shapes against the domains: every runtime input present once, every name an input, every rank equal to the input's, and every extent admitted ([`DimDomain::admits`](./DimDomain.md#admits)). Raises [`ClikaRT::Error`](../Error.md) (InvalidArgument) naming the input and the dimension that failed.
Declared in `ClikaRT/graph/model_graph.h`, line 1121
### bench(vector\, BenchOptions) {#bench}
[`BenchReport`](./BenchReport.md) **`bench`**(`const std::vector<`[`InputShape`](./InputShape.md)`>&` `shapes`, [`BenchOptions`](./BenchOptions.md) `options` `=` `{}`) `const`
Time the graph on synthesized inputs of the given shapes. The shapes are validated as [`validate_shapes`](./ModelGraph.md#validate_shapes) does, one tensor per input is filled per `options.fill` on the benchmark device, `options.warmup` untimed runs precede `options.iterations` timed ones, and the report carries every timed run's wall-clock milliseconds (each output synchronized before the clock stops), the summary statistics, the process's peak resident set and the device's memory counters. Raises [`ClikaRT::Error`](../Error.md) on a shape the domains reject, a run that fails, a graph that is not finalized, or one that [`optimize`](./ModelGraph.md#optimize), [`finalize`](./ModelGraph.md#finalize) or [`attach_kv_cache`](./ModelGraph.md#attach_kv_cache) is changing (`FAILED_PRECONDITION`).
Declared in `ClikaRT/graph/model_graph.h`, line 1137
### bench(vector\\>, BenchOptions) {#bench-2}
[`BenchReport`](./BenchReport.md) **`bench`**(
`const std::vector>&` `shapes`,
[`BenchOptions`](./BenchOptions.md) `options` `=` `{}`
) `const`
Time the graph on synthesized inputs of the given shapes. The shapes are validated as [`validate_shapes`](./ModelGraph.md#validate_shapes) does, one tensor per input is filled per `options.fill` on the benchmark device, `options.warmup` untimed runs precede `options.iterations` timed ones, and the report carries every timed run's wall-clock milliseconds (each output synchronized before the clock stops), the summary statistics, the process's peak resident set and the device's memory counters. Raises [`ClikaRT::Error`](../Error.md) on a shape the domains reject, a run that fails, a graph that is not finalized, or one that [`optimize`](./ModelGraph.md#optimize), [`finalize`](./ModelGraph.md#finalize) or [`attach_kv_cache`](./ModelGraph.md#attach_kv_cache) is changing (`FAILED_PRECONDITION`).
Declared in `ClikaRT/graph/model_graph.h`, line 1146
### bench(NamedTensors, BenchOptions) {#bench-3}
[`BenchReport`](./BenchReport.md) **`bench`**(`const` [`NamedTensors`](../NamedTensors.md)`&` `inputs`, [`BenchOptions`](./BenchOptions.md) `options` `=` `{}`) `const`
Time the graph on synthesized inputs of the given shapes. The shapes are validated as [`validate_shapes`](./ModelGraph.md#validate_shapes) does, one tensor per input is filled per `options.fill` on the benchmark device, `options.warmup` untimed runs precede `options.iterations` timed ones, and the report carries every timed run's wall-clock milliseconds (each output synchronized before the clock stops), the summary statistics, the process's peak resident set and the device's memory counters. Raises [`ClikaRT::Error`](../Error.md) on a shape the domains reject, a run that fails, a graph that is not finalized, or one that [`optimize`](./ModelGraph.md#optimize), [`finalize`](./ModelGraph.md#finalize) or [`attach_kv_cache`](./ModelGraph.md#attach_kv_cache) is changing (`FAILED_PRECONDITION`).
Declared in `ClikaRT/graph/model_graph.h`, line 1156