SDN Node Update via Alpha-Beta Propagation

Resolve Bottlenecks,
Find Innovative Solutions
Generate Solutions

Solution Overview

Problem

Current software-defined networks face bottlenecks in updating software across large numbers of nodes, leading to prolonged update times, state issues due to mixed software versions, and single-point failures in file transfer, especially in geographically distributed networks.

Innovation Solution

Implementing a method where a first set of 'Alpha' nodes is selected and updated, then used to propagate updates to 'Beta' nodes, which can subsequently become 'Alpha' nodes, distributing the update process and reducing reliance on a single centralized engine, thereby enhancing redundancy and efficiency.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Device complexity

If a centralized engine is used to push software updates to all nodes, then update control is centralized and simple, but update time becomes extremely long for large networks and a bottleneck is created

Engineering Contradiction:
Improveupdate control complexityVSAvoidupdate speed
Core Design Contradiction:
Device complexityVSProductivity

Solution Approach 1:

The network is segmented into multiple zones or regions, and update propagation is divided into phases where Alpha nodes update first, then serve as sources for Beta nodes. This segmentation allows parallel update propagation across different network segments, dramatically improving update speed while maintaining controlled complexity through hierarchical management.

Inventive Principle:
Principle #1Segmentation

Solution Approach 2:

Alpha nodes are pre-selected and pre-configured with update capabilities before the update process begins. These nodes are prepared in advance to serve as distribution points, allowing the update process to start immediately without waiting for sequential propagation from the centralized engine to every node.

Inventive Principle:
Principle #10Preliminary action

2Device complexity

If a single centralized engine pushes updates, then update distribution is simple to manage, but the system creates a single point of failure with no redundancy

Engineering Contradiction:
Improvedistribution management complexityVSAvoidsystem redundancy
Core Design Contradiction:
Device complexityVSReliability

Solution Approach 1:

Alpha nodes act as intermediary distribution points between the centralized engine and Beta nodes. This intermediary layer distributes the reliance away from the single centralized engine, creating redundant update paths. If the centralized engine fails, Alpha nodes that have already received updates can continue propagating them to Beta nodes independently.

Inventive Principle:
Principle #24Intermediary (Mediator)

Solution Approach 2:

The update distribution function is segmented between the centralized engine (which updates Alpha nodes) and the Alpha nodes themselves (which update Beta nodes). This segmentation creates multiple independent update sources, eliminating the single point of failure while the centralized engine maintains overall coordination simplicity.

Inventive Principle:
Principle #1Segmentation

3Stability of the object's composition

If all nodes are updated simultaneously from a centralized source, then update consistency is maintained, but network bandwidth is overwhelmed and update time increases

Engineering Contradiction:
Improvesoftware version consistencyVSAvoidupdate throughput
Core Design Contradiction:
Stability of the object's compositionVSProductivity

Solution Approach 1:

The node population is segmented into Alpha and Beta groups with different update roles. Alpha nodes receive updates first and serve as local distribution points, while Beta nodes receive updates from their nearest Alpha nodes. This segmentation creates multiple localized update streams that don't compete for centralized bandwidth, improving overall throughput while maintaining version consistency through coordinated phase transitions.

Inventive Principle:
Principle #1Segmentation

Solution Approach 2:

The update propagation is moved from a single-dimensional centralized model to a two-dimensional distributed model, where updates flow both from the centralized engine to Alpha nodes and from Alpha nodes to Beta nodes in parallel. This dimensional change enables concurrent update operations across multiple network paths, dramatically increasing throughput without sacrificing consistency.

Inventive Principle:
Principle #17Another dimension (Dimensionality change)

4Adaptability or versatility

If mixed software versions exist across nodes, then gradual adaptation is possible, but state issues and network conflicts arise

Engineering Contradiction:
Improvegradual update adaptationVSAvoidnetwork state consistency
Core Design Contradiction:
Adaptability or versatilityVSReliability

Solution Approach 1:

The update process is divided into periodic phases: Phase 1 updates Alpha nodes while Beta nodes remain on the old version; Phase 2 updates Beta nodes using Alpha nodes as sources. This periodic, phased approach allows gradual adaptation while maintaining network functionality throughout. Version conflicts are minimized because each phase transitions a specific subset of nodes, and the system is designed to handle the expected version mix at each phase boundary.

Inventive Principle:
Principle #19Periodic action

Data Source

PatentUS11271813B2Node update in a software-defined network
Publication Date: 2022.03.08 CISCO TECHNOLOGY INC
  • US11271813B2 patent drawing
  • US11271813B2 patent drawing
  • US11271813B2 patent drawing

AI summary

A method may include identifying an update file for a plurality of nodes; selecting a first set of nodes of the plurality of nodes based on a set of node selection criteria; sending the update file to the first set of nodes via a software-defined network (SDN); receiving a first message from a first node of the first set of nodes indicating that the first node is ready to host the update file; identifying a second node that is connected to the first node responsive to receiving the first message from the first node; sending a first instruction to the second node for the second node to obtain the update file from the first node; receiving a second message from the second node indicating that the second node is ready to host the update file; and adding the second node to the first set of nodes.