GPU Appearance Frequency Calculation via Thread Group Segmentation
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Graphics Processing Units (GPUs) face inefficiencies in calculating appearance frequency due to the need for atomic processing, which results in increased waiting times and delays for other threads, especially when dealing with simultaneous memory access.
Innovation Solution
The implementation of a non-transitory computer-readable recording medium with an appearance frequency calculation program that constructs thread groups to divide input data, allowing each thread to manage its data section and reduce atomic processing by using methods like bit string generation and duplication number calculation to minimize simultaneous access.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Measurement precision
If atomic processing is used to calculate appearance frequency in GPU, then calculation accuracy is ensured, but processing speed decreases due to increased waiting times and delays
Solution Approach 1:
The patent divides the data into multiple data groups and assigns each thread group to process a specific data group. This segmentation allows parallel processing of different data portions without requiring atomic operations for every access, as each thread group operates on its own segment. The appearance frequency calculation is segmented into: (1) dividing input data into multiple data groups, (2) assigning thread groups to process specific segments, and (3) each thread within a group processing specific data elements within its assigned segment.
Solution Approach 2:
The patent merges the processing of multiple threads into thread groups where threads within the same group cooperate to process a data group. Instead of each thread independently performing atomic operations, threads are merged into groups that collectively process their assigned data segment. This merging reduces the total number of atomic operations required, as the thread group as a unit manages its local appearance frequency counts without interfering with other thread groups.
2Productivity
If multiple threads simultaneously access memory to calculate appearance frequency, then processing parallelism is achieved, but waiting times increase due to atomic processing requirements
Solution Approach 1:
The patent segments both the data and the processing threads into corresponding groups. Each thread group is assigned a specific data group and processes it independently. This segmentation eliminates the need for atomic operations between different thread groups, as they operate on disjoint data segments. The segmentation creates independent processing units that can execute in parallel without synchronization overhead.
Solution Approach 2:
The patent performs preliminary assignment of data groups to thread groups before processing begins. This preliminary action establishes clear boundaries and responsibilities for each thread group, allowing them to proceed with processing without needing to negotiate or synchronize during execution. The data is pre-divided and assigned, so threads can immediately begin processing their assigned segments without waiting for atomic operation completion from other threads.
Data Source
AI summary
A recording medium recording an appearance frequency calculation program for causing an information processing apparatus to execute processing includes: construction processing of constructing thread groups each including threads; acquisition processing in which the thread group acquires a data group including a same number of pieces of data as a number of threads constituting the thread group, each thread being responsible for one piece of data of the data group; and addition processing in which the thread adds one to a first storage area that stores an appearance frequency of a first numerical value, and a duplication number indicating a number of duplication is added to the first storage area when the own thread is a representative thread that is present alone in the thread group that is responsible for the data of the first numerical value when the first numerical value is duplicated in the data group.