Sack Data Structure for Parallel Programming
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing parallel programming frameworks face challenges in performance due to traditional data structures that are often bundled with fixed runtime systems, making them difficult to debug and optimize for multicore architectures.
Innovation Solution
The introduction of a data structure called Sack, which comprises global and local containers accessible by multiple threads, allowing for dynamic splitting and merging of data structures during parallel processing, enabling efficient parallel programming with improved debug and trace capabilities.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Ease of manufacture
If traditional data structures are bundled with fixed runtime systems, then implementation simplicity is improved, but debug and trace capabilities deteriorate
Solution Approach 1:
The patent segments the data structure into multiple independent containers (global container and local containers) that can be individually accessed and debugged. This segmentation allows developers to trace and debug specific container operations without being constrained by a fixed runtime system, thus improving debug and trace capabilities while maintaining implementation simplicity through the modular container design.
2Productivity
If global container is shared by all threads, then data sharing efficiency is improved, but thread isolation and security deteriorate
Solution Approach 1:
The patent divides the data structure into a global container accessible by all threads and multiple local containers assigned to individual threads. This segmentation enables efficient data sharing through the global container while maintaining thread isolation through local containers, as each thread has dedicated access to its local container and shared access to the global container through controlled operations.
Solution Approach 2:
Different portions of the data structure have different access qualities: the global container provides shared access for collaboration, while local containers provide exclusive access for thread-specific operations. This local quality differentiation optimizes both data sharing efficiency and thread isolation by allowing threads to access global data when needed while maintaining private working spaces in local containers.
3Ease of manufacture
If data structure is fixed, then implementation simplicity is improved, but adaptability to different parallel processing scenarios deteriorates
Solution Approach 1:
The patent implements a dynamic data structure where the global container can be split into multiple local containers and merged back together during parallel processing. This dynamic transformation allows the data structure to adapt to different parallel processing scenarios and workloads while maintaining a simple unified structure when parallelism is not needed, thus achieving both implementation simplicity and adaptability.
Data Source
Figure 1
Figure 2~3
Figure 4~5
AI summary
System and method embodiments are provided for creating data structure for parallel programming. A method for creating data structures for parallel programming includes forming, by one or more processors, one or more data structures, each data structure comprising one or more global containers and a plurality of local containers. Each of the global containers is accessible by all of a plurality of threads in a multi-thread parallel processing environment. Each of the plurality of local containers is accessible only by a corresponding one of the plurality of threads. A global container is split into a second plurality of local containers when items are going to be processed in parallel and two or more local containers are merged into a single global container when a parallel process reaches a synchronization point.