Tuple-to-Message Interface for SDN Controller Consistency
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
In Software-Defined Networking (SDN), interfacing between tuple-based and message-driven control entities is challenging due to differences in consistency models, with tuple-based systems relying on eventual consistency and message-driven systems requiring strict protocols and state machines.
Innovation Solution
A method for interfacing between a tuple-based local controller and a message-based central controller using a message-based protocol, where the local controller identifies changed tuples, generates messages, and sends them to the central controller, utilizing cacheable and non-cacheable output tables and establishing dependencies to ensure ordered messaging.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If a tuple-based controller uses eventual consistency to generate output from input data, then the system can operate with higher flexibility and simpler state management, but it becomes difficult to interface with message-driven controllers that require strict protocols and state machines
Solution Approach 1:
The patent introduces an intermediary interface layer that translates between tuple-based eventual consistency models and message-driven strict protocol requirements. This mediator converts tuple operations into message-driven controller commands, enabling communication between the two different control paradigms without requiring either side to change its fundamental operating model.
2Speed
If the local controller sends messages to the central controller at various times, then the system can respond dynamically to changes, but it becomes challenging to ensure strict ordering of messages required by the central controller
Solution Approach 1:
The local controller pre-establishes dependencies between output tables before messages are generated. By defining the ordering relationships in advance, the system can dynamically respond to changes while ensuring that messages are always sent in the correct sequence according to the pre-defined dependency graph, resolving the conflict between speed and reliability.
Solution Approach 2:
The patent replaces the mechanical approach of enforcing message order through timing and synchronization mechanisms with a logical dependency-based system. Instead of using time-based ordering, the system uses a directed acyclic graph (DAG) of dependencies to determine message order, allowing dynamic response while maintaining strict ordering guarantees.
3Productivity
If the local controller uses cacheable output tables to store processed data tuples, then system performance is improved, but it becomes necessary to establish complex dependencies between records to ensure proper message sequencing
Solution Approach 1:
The patent segments the output data structure into multiple independent output tables, each with its own caching mechanism. By dividing the data into separable units with defined relationships, the system can cache data efficiently while managing dependencies between segments through a structured dependency graph, reducing the complexity of overall dependency management.
Data Source
AI summary
Some embodiments of the invention provide a novel method for interfacing between a first tuple-based controller and a second controller using a message-based protocol. The method of some embodiments identifies a set of changed tuples stored in a set of output tables, generates a set of messages based on the changed tuples, and sends the generated set of messages to a second controller. In some embodiments, the first and second controllers are parts of a network control system that manages forwarding elements to implement a logical network.