Routing Policy Compiler Abstraction Layer
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Conventional routers face challenges such as supporting only one version of client protocol software at a time, processing route updates from thousands of peers, requiring recompilation for new routing protocol attributes, skipping unsupported statements, and experiencing network instability during configuration transitions.
Innovation Solution
A routing policy compiler generates a configuration data abstraction layer that supports multiple software versions and client protocols, verifies policy statements, and optimizes route updates, allowing new attributes to be added without recompilation, and transitions between configuration states without intermediate instability.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If conventional routers support only one version of client protocol software at a time, then the router maintains simple protocol handling logic, but the router cannot support multiple protocol versions with differing capabilities simultaneously
Solution Approach 1:
The patent segments the protocol handling by creating separate protocol instance modules for different protocol versions. Each protocol instance maintains its own capability set and processing logic, allowing multiple versions to coexist without interfering with each other. The router can instantiate multiple protocol software versions simultaneously, each handling routes according to its specific capabilities.
Solution Approach 2:
The routing policy compiler creates a universal policy language that can be interpreted by multiple protocol instances. This universal policy representation allows a single policy configuration to be applied across different protocol versions, reducing the need for separate handling logic for each protocol while maintaining version-specific capabilities.
2Adaptability or versatility
If conventional routers support thousands of peers with unique policies, then the router can handle diverse routing requirements, but the routing protocols experience heavy processing burden during route updates
Solution Approach 1:
The patent uses template-based policy definitions where common routing policies are defined once as templates and then instantiated for multiple peers. Instead of processing unique policies for each peer individually, the system copies and applies template policies to groups of peers with similar requirements, dramatically reducing processing overhead during route updates while maintaining the ability to customize policies when needed.
Solution Approach 2:
The patent merges multiple individual peer policies into aggregated policy groups based on common characteristics. Route updates are processed at the group level rather than individually for each peer, combining processing operations to improve efficiency while still applying appropriate policies to each peer within the group.
3Reliability
If conventional routers require recompilation of policy compiler for new routing protocol attributes, then the software maintains tight integration with protocol specifications, but adding new attributes requires system-wide recompilation even when changes are isolated to one protocol
Solution Approach 1:
The patent extracts protocol-specific attribute handling into separate, isolated modules within the policy compiler. Each routing protocol has its own attribute definition and processing module that is independent of other protocols. When a new attribute is added to one protocol, only that specific module needs to be updated, not the entire policy compiler, maintaining tight integration while enabling localized updates.
Solution Approach 2:
The patent implements a dynamic policy compiler architecture where protocol attribute definitions can be loaded and updated at runtime without requiring full recompilation. The system can dynamically load new protocol attributes and integrate them into the existing policy processing framework, allowing flexible updates while maintaining reliable integration with protocol specifications.
4Ease of operation
If conventional routers skip unsupported policy statements during execution, then the router can process policies for protocols with limited capabilities, but users cannot know what statements are being skipped and cannot predict system behavior
Solution Approach 1:
The patent implements a policy verification mechanism that provides feedback to users about which policy statements are supported and which are skipped during execution. The system analyzes the policy configuration against the capabilities of the target protocol instance and generates detailed reports indicating unsupported statements, allowing users to understand and predict system behavior while maintaining compatibility with protocols of varying capabilities.
5Ease of manufacture
If conventional routers transition among intermediate configuration states when adding new routing policies, then the router can apply policies incrementally, but network stability is compromised due to undesirable intermediate states
Solution Approach 1:
The patent verifies the complete new routing policy against the existing policy set and protocol capabilities before applying any changes. The verification process checks for conflicts, compatibility, and correctness of the entire policy configuration in advance. Only after successful verification is the new policy activated, transitioning the system directly from the old policy state to the new policy state without passing through unstable intermediate configurations.
Data Source
AI summary
A routing policy compiler generates a configuration data abstraction layer of a routing policy which maps configuration to an intermediate layer comprising fields, operators and arguments. A policy repository verifies the intermediate layer against a set of verification rules for one or more client protocols including versions thereof. The policy repository may generate compiled policy transmission language for use by one or more client protocols including versions thereof. The policy compiler supports multiple software versions of client protocols with differing capabilities as well as differing client protocols. In some embodiments, an optimization may be performed on a compiled policy so that route updates are processed more efficiently. The policy compiler may permit the addition of new attributes to a routing protocol without having to recompile. Policy statements may be verified for more that one client protocol including more than one version of a client protocol. Routers may be transitioned between configuration states without transitioning between intervening states.