Many-Core Test Data Compaction Using Hierarchical Scan Clusters
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Conventional test compression tools for many-core processors are inefficient due to treating all cores as a single piece of logic, failing to leverage core similarities, leading to high automatic test pattern generation (ATPG) time, memory requirements, and test execution time, especially in systems with thousands of cores.
Innovation Solution
A hierarchical test solution that groups cores into super cores and clusters, using a hybrid combination of spatial and temporal compactors to compare and compact scan chain outputs, reducing the need for data transmission and hardware overhead, and enabling scalable and flexible testing.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Quantity of substance
If conventional test compression tools treat all cores as a single piece of random logic, then test results can be compacted, but ATPG time, memory requirements, and test execution time become extremely high
Solution Approach 1:
The patent segments the many-core processor into hierarchical groups: cores are divided into super-cores, which are further divided into clusters. This segmentation allows test compression to be applied at multiple levels (intra-super-core, inter-super-core, intra-cluster, inter-cluster), reducing the overall test data volume and ATPG time by processing smaller segments rather than treating all cores as a single large logic block
Solution Approach 2:
The patent introduces a hierarchical dimension to test compression by organizing cores into multiple levels (cores → super-cores → clusters). This multi-dimensional approach enables simultaneous compression at different hierarchical levels, reducing test data volume and execution time more effectively than conventional single-level compression
2Quantity of substance
If conventional test compression tools compact test results from all cores, then data volume is reduced, but the methods are not scalable with respect to design size
Solution Approach 1:
The hierarchical segmentation into cores, super-cores, and clusters enables scalable test compression. Each level can be independently configured and processed, allowing the system to scale to different design sizes by adjusting the number and organization of clusters without requiring a complete redesign of the test compression approach
Solution Approach 2:
The patent employs dynamic test compression where the hierarchical organization and compression strategy can be adapted based on the specific design size and configuration. The system can dynamically adjust which compression techniques are applied at each hierarchical level to optimize for different design scales
3Quantity of substance
If conventional test compression tools perform compaction on collective results from all cores, then test results are compacted, but hardware overhead and test execution time increase significantly
Solution Approach 1:
By segmenting test compression into hierarchical levels, the hardware overhead is distributed across multiple manageable components rather than requiring a single large compression unit. Each super-core and cluster has its own compression logic, reducing the complexity of any individual component while achieving overall data reduction
Solution Approach 2:
The patent merges compression functions across multiple hierarchical levels, where compression occurs both within super-cores and across them, and similarly within and across clusters. This merging of compression stages achieves greater data reduction efficiency while keeping individual hardware components relatively simple
Data Source
AI summary
A method for testing a many-core processor comprises grouping a plurality of cores in the processor into a plurality of super cores, wherein each super core comprises one or more scan chains that propagate through a respective super core. Further, the method comprises grouping the plurality of super cores into a plurality of clusters. The method also comprises comparing one or more scan chain outputs of respective super cores in each cluster using a network of XOR and OR gates to generate a single bit fault signature for each scan chain in a respective cluster and compacting the single bit fault signatures for each scan chain using a hybrid of spatial and temporal compactors to generate a single bit fault signature for each cluster. The method also comprises method of using a cost function to obtain hierarchical parameters to achieve optimized ATPG effort, area overhead and test time.