Software Packet Switching Graph Architecture

Resolve Bottlenecks,
Find Innovative Solutions
Generate Solutions

Solution Overview

Problem

Current software switching paths are tightly integrated with the operating system, making it difficult to abstract the control plane, leading to performance issues, integration challenges, and lack of modularity, especially in distributed systems and symmetric multi-processor environments.

Innovation Solution

A switching architecture that abstracts the data plane from the control plane, using API abstraction and a software-based graph of feature nodes to process packets, allowing for modular and reusable feature code across central or distributed routing platforms, with each node containing private configuration data and connections that are feature-independent for easy integration of new features.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Ease of manufacture

If current software switching paths are tightly integrated with the operating system, then the implementation is straightforward within the OS, but it becomes difficult to abstract the control plane and integrate new features

Engineering Contradiction:
Improveease of implementationVSAvoidease of feature integration
Core Design Contradiction:
Ease of manufactureVSAdaptability or versatility

Solution Approach 1:

The patent segments the switching path into modular feature nodes that can be independently configured and integrated. Each feature is represented as a separate node in a graph structure, allowing individual features to be added, removed, or modified without affecting the entire switching path. This modular segmentation enables easy abstraction of the control plane while maintaining ease of implementation through standardized node interfaces.

Inventive Principle:
Principle #1Segmentation

2Adaptability or versatility

If runtime checks are used to test whether features should be applied to packets, then the switching path can be flexible, but performance deteriorates and modularity is reduced

Engineering Contradiction:
Improveflexibility of packet processingVSAvoidpacket processing performance
Core Design Contradiction:
Adaptability or versatilityVSProductivity

Solution Approach 1:

The patent applies preliminary action by pre-configuring the switching path as a graph of feature nodes before packet processing begins. The graph structure预先 defines the packet processing path, eliminating the need for runtime checks to determine which features to apply. Packets simply traverse the pre-established graph, significantly improving performance while maintaining flexibility through the ability to reconfigure the graph structure.

Inventive Principle:
Principle #10Preliminary action

3Stability of the object's composition

If the switching path is tightly integrated inside the operating system, then the code is cohesive, but it is not suitable for running in a symmetric multi-processor system

Engineering Contradiction:
Improvecode coherenceVSAvoidsuitability for SMP systems
Core Design Contradiction:
Stability of the object's compositionVSAdaptability or versatility

Solution Approach 1:

The patent introduces an intermediary layer in the form of a standardized graph representation that sits between the operating system and the feature implementation. This graph structure serves as a mediator that maintains code coherence through standardized node interfaces while enabling SMP compatibility by allowing the graph to be distributed across multiple processors. The intermediary abstraction decouples the tight integration while preserving system coherence.

Inventive Principle:
Principle #24Intermediary (Mediator)

Data Source

PatentUS7525973B1Flexible software-based packet switching path
Publication Date: 2009.04.28 CISCO TECHNOLOGY INC
  • US7525973B1 patent drawing
  • US7525973B1 patent drawing
  • US7525973B1 patent drawing

AI summary

A software-implemented switching path includes separate control and data planes with the data plane having a graph of feature nodes with each node implementing a feature to be applied to a packet being switched. Each feature node includes private data and code which are utilized to apply the feature to the packet. The packet is switched to a next node based on packet-specific context data.