Dynamic Data Packet Slicing for Flexible Chip Verification Access
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Current data packet definitions in chip design and verification are static and complex, leading to inconvenient access and maintenance, resulting in high programming workload and low efficiency.
Innovation Solution
A method and system for dynamically defining complex data packets using a byte-type-based two-dimensional data structure with 10 types of slicing manners, allowing flexible selection and manipulation of data elements.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Ease of manufacture
If static struct definition is used for data packets, then data packet structure can be defined, but access and maintenance become complex and programming workload increases
Solution Approach 1:
The patent transforms static struct definitions into dynamic data packet representations using a byte array-based approach with configurable parameters. The data packet structure can be dynamically adjusted through parameters like row_count, col_count, and data_type, allowing flexible access and maintenance without requiring multiple struct definitions. This dynamic approach resolves the contradiction by enabling easy definition while maintaining operational simplicity.
Solution Approach 2:
The patent creates a universal data packet representation that can handle various data packet types through a single unified structure. By using a generic byte array with configurable dimensions and types, the system can represent different data packet formats (IP headers, OTN frames, etc.) without requiring separate struct definitions for each type. This multi-functionality simplifies both definition and access operations.
2Adaptability or versatility
If multiple structs are defined for different data packets, then various data packet types can be represented, but programming complexity and workload increase significantly
Solution Approach 1:
The patent implements a universal data packet representation using a single byte array-based structure that can accommodate various data packet types. Instead of defining separate structs for IP headers, OTN frames, and other packet types, the system uses configurable parameters (row_count, colCount, data_type, byte_size) to adapt the same structure to different packet formats. This eliminates the need for multiple struct definitions and significantly reduces programming complexity.
Solution Approach 2:
The patent changes the approach from structural definition to parameter configuration. Rather than defining different structs for different packet types, the system uses parameter changes (dimensions, data types, sizes) to adapt a single universal structure to represent various packet types. This parameter-driven approach maintains versatility while dramatically reducing programming complexity.
3Productivity
If conventional arrays and structs are used, then programming can be performed, but data packet access and maintenance require complex processing steps
Solution Approach 1:
The patent segments the data packet into a two-dimensional byte array structure with configurable rows and columns, allowing systematic access to specific data elements. This segmentation enables simple indexing and access operations (e.g., packet[row][col]) without complex processing steps. The segmented structure maintains programming efficiency while dramatically improving ease of access and maintenance operations.
Data Source
AI summary
The present disclosure discloses a method and a system for operating a complex data packet capable of being dynamically defined, and relates to the field of chip design and verification, and software technologies. The method includes: constructing a two-dimensional data structure of a data packet based on an actual programming requirement; performing slicing processing on the two-dimensional data structure of the data packet in a slicing manner; selecting an element corresponding to a processed slice from the data packet, and performing a storage and retrieval operation on a data packet element; marking each processed slice based on the processed slice; denoting a marked slice as a segment, and performing an element access operation on the segment in the data packet by using a mark; and comparing different data packets based on marked data packets and segments.