Scatter Gather List Handling for Out of Order Systems

Resolve Bottlenecks,
Find Innovative Solutions
Generate Solutions

Solution Overview

Problem

In out-of-order data transfer systems, Scatter-Gather Lists (SGLs) face inefficiencies due to thrashing, where cache contents are discarded and newer elements are fetched, leading to performance degradation, especially when accessing non-contiguous memory buffers.

Innovation Solution

The method involves generating multiple Child IOs from a Parent IO, each at the granularity of storage side memory, with separate SGLs processed independently and in-order within each Child IO, transforming out-of-order IO transfers into in-order transfers and reducing thrashing by caching and processing Child IOs independently.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Productivity

If SGL caching is used for out-of-order IO transfers, then data transfer capability is improved, but cache thrashing occurs causing performance degradation

Engineering Contradiction:
Improvedata transfer capabilityVSAvoidcache thrashing
Core Design Contradiction:
ProductivityVSLoss of time

Solution Approach 1:

The patent segments the original out-of-order IO transfer into multiple Child IOs, each representing a contiguous memory range. By dividing the transfer operation into segmented Child IOs with ordered memory access patterns, the system eliminates cache thrashing while maintaining data transfer capability. Each Child IO is processed independently with its own SGL cache, preventing interference between out-of-order transfers.

Inventive Principle:
Principle #1Segmentation

2Adaptability or versatility

If SGL elements are stored non-contiguously in memory, then flexibility in memory allocation is improved, but list traversal complexity increases

Engineering Contradiction:
Improvememory allocation flexibilityVSAvoidlist traversal complexity
Core Design Contradiction:
Adaptability or versatilityVSDevice complexity

Solution Approach 1:

The patent implements nested SGL structures where Child SGLs are contained within a Parent SGL. Each Child SGL points to contiguous memory ranges, simplifying traversal within children. The Parent SGL orchestrates the sequence of Child SGLs, providing high-level flexibility. This nesting allows non-contiguous memory allocation at the parent level while maintaining contiguous access patterns at the child level.

Inventive Principle:
Principle #7Nested doll (Nesting)

3Quantity of substance

If cache contents are discarded and newer elements are fetched, then memory utilization is improved, but transfer speed decreases

Engineering Contradiction:
Improvememory utilizationVSAvoidtransfer speed
Core Design Contradiction:
Quantity of substanceVSSpeed

Solution Approach 1:

The patent performs preliminary actions by pre-fetching and caching SGL elements for multiple Child IOs before actual data transfer begins. The system anticipates future memory access patterns and loads relevant SGL elements into cache in advance. This preliminary caching ensures that when data transfer occurs, the cache contains necessary elements, maintaining high transfer speed without excessive discarding of valid cache contents.

Inventive Principle:
Principle #10Preliminary action

Data Source

PatentUS9778858B1Apparatus and method for scatter gather list handling for an out of order system
Publication Date: 2017.10.03 MICROSEMI SOLUTIONS US INC
  • US9778858B1 patent drawing
  • US9778858B1 patent drawing
  • US9778858B1 patent drawing

AI summary

A method and apparatus for handling SGLs for out of order systems is disclosed. The method involves generating multiple Child IOs from an original IO, each Child IO being at the granularity of a storage side memory; generating separate SG lists for each Child IO; and processing each Child IO independently of other Child IOs and in order with each Child IO for data transfer. As each Child IO is generated at the granularity of the storage side memory, the Child IOs can be processed independently of each other and in-order within each Child IO. Thus, an out-of order IO transfer is transformed into an in-order IO transfer.