Static DAG Compilation for Autonomous Vehicle Prediction Graphs

Resolve Bottlenecks,
Find Innovative SolutionsGenerate Solutions

Solution Overview

Problem

Autonomous vehicle prediction systems face inefficiencies in determining object properties as they must dynamically construct and reconfigure directed acyclic graphs (DAGs) at runtime, consuming computational resources and energy, which affects operating efficiency.

Innovation Solution

Building DAGs at compile-time, where nodes are ordered by depth to ensure dependencies are updated before the node itself, resulting in a graph-based program specification that is compiled into a computer-readable program and executed at runtime without changing the node order, optimizing the prediction process.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Adaptability or versatility

If DAGs are constructed and reconfigured dynamically at runtime, then the system can adapt to different prediction scenarios, but computational resources and energy are consumed, reducing operating efficiency

Engineering Contradiction:

Improveadaptability to different prediction scenariosVSAvoidcomputational energy consumption

Core Design Contradiction:

Adaptability or versatilityVSUse of energy by moving object

Solution Approach 1:

The patent applies preliminary action by constructing and ordering the DAG at compile-time rather than runtime. The compiler analyzes the graph structure, determines node depths, and establishes execution sequences in advance. This pre-computation eliminates the need for dynamic construction during runtime, significantly reducing computational energy consumption while maintaining adaptability through the pre-established execution plan.

Inventive Principle:

Principle #10Preliminary action

2Adaptability or versatility

If DAGs are constructed and reconfigured dynamically at runtime, then the system can adapt to different prediction scenarios, but computational overhead increases, affecting operating efficiency

Engineering Contradiction:

Improveadaptability to different prediction scenariosVSAvoidcomputational overhead

Core Design Contradiction:

Adaptability or versatilityVSDevice complexity

Solution Approach 1:

The compiler performs preliminary analysis of the DAG structure, calculating node depths and determining execution sequences before runtime. This advance preparation simplifies the runtime execution to merely following the pre-determined sequence, dramatically reducing computational overhead and complexity during actual operation while preserving full adaptability.

Inventive Principle:

Principle #10Preliminary action

3Ease of operation

If nodes are processed in arbitrary order at runtime, then implementation is simpler, but dependency violations occur causing incorrect property determination

Engineering Contradiction:

Improveimplementation simplicityVSAvoiddependency correctness

Core Design Contradiction:

Ease of operationVSReliability

Solution Approach 1:

The compiler performs preliminary depth calculation for each node and establishes a strict execution sequence based on these depths. This pre-computed ordering guarantees that parent nodes are always processed before their children, ensuring dependency correctness. The runtime system simply follows this pre-established sequence, maintaining both reliability and ease of operation.

Inventive Principle:

Principle #10Preliminary action

Solution Approach 2:

The patent replaces the mechanical runtime dependency checking mechanism with a compile-time depth-based ordering system. Instead of dynamically verifying dependencies during execution, the compiler embeds the dependency structure into the node sequence itself, eliminating the need for complex runtime dependency management while ensuring correctness.

Inventive Principle:

Principle #28Mechanics substitution (Replace mechanical system)

4Productivity

If DAG construction is performed at compile-time, then computational overhead and energy consumption are reduced, but the system loses flexibility in adapting to runtime changes

Engineering Contradiction:

Improveoperating efficiencyVSAvoidflexibility in adapting to runtime changes

Core Design Contradiction:

ProductivityVSAdaptability or versatility

Solution Approach 1:

The compiler performs preliminary DAG construction and node ordering at compile-time, establishing an execution sequence based on node depths. This pre-computation significantly improves operating efficiency by eliminating runtime construction overhead. The system maintains flexibility because the pre-computed sequence is specifically designed to handle the full range of predicted scenarios, and the depth-based ordering naturally adapts to different execution paths without requiring runtime reconfiguration.

Inventive Principle:

Principle #10Preliminary action

Data Source

PatentUS11480969B2Method and system for constructing static directed acyclic graphs

Publication Date: 2022.10.25 FORD GLOBAL TECH LLC

AI summary

At compile-time, a processor develops a computer program by receiving an input that includes multiple nodes and connections between pairs of the nodes. The nodes represent object properties such as properties of objects that an autonomous vehicle (AV) detects while moving about an environment. For each node, the system will identify a depth that represents a number of nodes along a longest path from that node to any available input node. The system will order the nodes by depth in a sequence, and it will build a graph-based program specification that includes the nodes in the sequence, along with the connections. The graph-based program specification may correspond to a directed acyclic graph (DAG). The system will compile the graph-based program specification into a computer-readable program, and it will save the computer-readable program to a memory so that the AV or other system can use it at run-time.