Transactional Memory Ring Buffer Prioritization

Resolve Bottlenecks,
Find Innovative Solutions
Generate Solutions

Solution Overview

Problem

Network processor integrated circuits face challenges in efficiently managing packet traffic as throughput requirements increase, particularly in handling buffer operations and prioritization within transactional memories.

Innovation Solution

The implementation of a transactional memory system with a command/push/pull (CPP) bus interface, featuring a ring buffer control circuit and memory unit, which uses head and tail pointers to manage buffer operations, including 'put into ring,' 'get from ring,' 'put into ring with low priority,' and 'get from one of a set of rings' commands, ensuring efficient buffer management and error handling.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Productivity

If traditional buffer management methods are used in network processors, then device complexity is reduced, but productivity and throughput decrease

Engineering Contradiction:
Improvepacket processing throughputVSAvoidbuffer management complexity
Core Design Contradiction:
ProductivityVSDevice complexity

Solution Approach 1:

The buffer memory is divided into multiple independent rings, each managed by dedicated head and tail pointers. This segmentation allows parallel access and independent management of different buffer regions, improving throughput while maintaining manageable complexity through modular organization.

Inventive Principle:
Principle #1Segmentation

Solution Approach 2:

The system implements dynamic buffer management where head and tail pointers are automatically updated during put and get operations. The ring buffer control circuit dynamically adjusts pointer positions and manages buffer allocation, enabling flexible and efficient packet processing without static constraints.

Inventive Principle:
Principle #15Dynamics

2Reliability

If ring buffer operations are implemented with full error handling, then reliability improves, but device complexity increases

Engineering Contradiction:
Improvebuffer operation reliabilityVSAvoiderror handling complexity
Core Design Contradiction:
ReliabilityVSDevice complexity

Solution Approach 1:

The ring buffer control circuit automatically performs error detection and handling through self-service mechanisms. The control circuit monitors ring full/empty conditions and manages error states without requiring external intervention, improving reliability while keeping the error handling logic integrated and manageable within the existing control structure.

Inventive Principle:
Principle #25Self-service

3Adaptability or versatility

If multiple ring buffers are implemented for different packet priorities, then adaptability improves, but device complexity increases

Engineering Contradiction:
Improvepacket prioritization capabilityVSAvoidring management complexity
Core Design Contradiction:
Adaptability or versatilityVSDevice complexity

Solution Approach 1:

The ring buffer system implements multi-functionality where the same basic ring buffer structure and control circuit can handle multiple packet priorities and different packet types. The universal ring buffer design with standardized put and get operations can be configured for different priority levels without requiring fundamentally different management mechanisms, achieving adaptability while controlling complexity through reuse of proven structures.

Inventive Principle:
Principle #6Universality (Multi-functionality)

Data Source

PatentUS9342313B2Transactional memory that supports a get from one of a set of rings command
Publication Date: 2016.05.17 NETRONOME SYSTEMS INC
  • US9342313B2 patent drawing
  • US9342313B2 patent drawing
  • US9342313B2 patent drawing

AI summary

A transactional memory (TM) includes a control circuit pipeline and an associated memory unit. The memory unit stores a plurality of rings. The pipeline maintains, for each ring, a head pointer and a tail pointer. A ring operation stage of the pipeline maintains the pointers as values are put onto and are taken off the rings. A put command causes the TM to put a value into a ring, provided the ring is not full. A get command causes the TM to take a value off a ring, provided the ring is not empty. A put with low priority command causes the TM to put a value into a ring, provided the ring has at least a predetermined amount of free buffer space. A get from a set of rings command causes the TM to get a value from the highest priority non-empty ring (of a specified set of rings).