SIMD Stride Predicate Lookup for Lower Processing Overhead
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
The computational overhead of recalculating predicates for varying strides in SIMD processors leads to increased processing times and resource consumption, offsetting the performance gains from using SIMD processing capabilities.
Innovation Solution
Precomputation of sub-vector width predicates in sequences, leveraging pre-established patterns to reduce the computational overhead, and applying these during the execution of an instance of the instruction.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If predicates are recalculated for varying strides in SIMD processors, then processing flexibility and adaptability are improved, but computational overhead and processing time increase
Solution Approach 1:
The patent precomputes predicate patterns for different stride values and stores them in a lookup table before actual processing. When a SIMD instruction executes, the processor simply retrieves the precomputed predicate pattern corresponding to the stride value, avoiding real-time recalculation. This preliminary action resolves the contradiction by maintaining adaptability through precomputed patterns while eliminating the time cost of recalculation during processing.
Solution Approach 2:
The patent prepares predicate patterns in advance and stores them in memory, creating a buffer that cushions against the computational overhead during actual SIMD execution. This beforehand cushioning allows the processor to handle varying strides efficiently by retrieving pre-prepared patterns rather than computing them on-the-fly, thus maintaining flexibility without sacrificing processing speed.
2Adaptability or versatility
If predicates are recalculated for varying strides in SIMD processors, then handling of complex data structures is improved, but resource consumption increases
Solution Approach 1:
The patent precomputes and stores predicate patterns for various stride values in a lookup table before processing begins. During SIMD execution, the processor retrieves the appropriate precomputed pattern based on the stride value, avoiding the need to recalculate predicates during processing. This approach maintains the ability to handle complex data structures with varying strides while minimizing computational resource consumption during actual execution.
3Manufacturing precision
If full predicate recalculation is performed for each SIMD instruction instance, then processing accuracy is improved, but productivity decreases
Solution Approach 1:
The patent precomputes predicate patterns with high accuracy and stores them in a lookup table. During SIMD instruction execution, the processor retrieves these precomputed patterns, ensuring processing accuracy is maintained while avoiding the time cost of recalculation. This resolves the contradiction by preserving accuracy through careful precomputation while boosting throughput by eliminating repeated calculations during high-speed execution.
Solution Approach 2:
The patent creates copies of predicate patterns for different stride values and stores them in a lookup table. Instead of recalculating predicates during each SIMD instruction, the processor copies the appropriate precomputed pattern from the lookup table based on the stride value. This copying approach maintains processing accuracy by using precomputed patterns while significantly improving productivity by avoiding repeated computational overhead.
Data Source
AI summary
System and techniques for creating a single-instruction multiple-data (SIMD) processor predicate based on stride length are described herein. When an instruction for a SIMD processor is received, and the instruction has a specified stride length, a predicate memory can be read to obtain a current predicate. A new predicate can be determined based on the stride length and the current predicate. The new predicate is written to the predicate memory. When an instance of the instruction is executed by the SIMD processor, the execution is performed on a subset of data loaded into the SIMD processor based on the new predicate read from the predicate memory.