Multi-threaded Constraint Solver with Cloned Planning Entities
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Constraint satisfaction solvers using heuristics and metaheuristics face inefficiencies due to the need for repeated copying of models across multiple threads, leading to high memory usage and processing time, especially when dealing with complex optimization problems, as each thread must independently alter and score solution states without interfering with others.
Innovation Solution
Implementing an object-oriented multi-threaded constraint satisfaction solver with a master thread and solver threads, where each solver thread has cloned planning entity objects, allowing for independent incremental changes and scoring without the need for repeated object copying, enabling parallel processing and incremental scoring.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If repeated copying of models is performed across multiple threads, then each thread can independently process solution states, but memory usage and processing time increase significantly
Solution Approach 1:
The patent applies selective copying by creating shallow copies of only the necessary planning entity objects rather than copying the entire model. This allows solver threads to have independent working copies of planning entities while sharing other model components, thereby reducing memory usage and copying overhead while maintaining independent processing capability.
2Reliability
If repeated copying of models is performed across multiple threads, then each thread can independently process solution states, but memory usage increases significantly
Solution Approach 1:
The patent implements selective shallow copying of planning entity objects instead of copying the entire model. This reduces the quantity of data that needs to be copied and stored in memory, while still providing each solver thread with sufficient independence to process solution states without interfering with other threads.
Solution Approach 2:
The patent enables shared read-only access to certain model components across multiple threads, allowing these components to serve multiple purposes simultaneously. This reduces redundant storage of identical data in each thread, thereby reducing overall memory consumption while maintaining thread independence for modifications.
3Productivity
If incremental changes and scoring are performed concurrently in multiple threads, then solution identification time is reduced, but thread interference occurs without proper isolation
Solution Approach 1:
The patent segments the model into distinct components: planning entity objects that are copied to each thread for independent modification, and other model components that remain shared and read-only. This segmentation allows concurrent incremental changes to planning entities without interfering with each other or the shared components, enabling parallel processing while maintaining reliability.
Solution Approach 2:
The patent uses cloned planning entity objects as intermediaries that allow solver threads to independently explore solution states. These intermediaries provide the necessary isolation so that incremental changes and scoring operations in one thread do not interfere with other threads, while still enabling efficient parallel processing.
Data Source
AI summary
An object-oriented method for multi-threading in a constraint satisfaction solver is provided. A master thread establishes a first solution state of a constraint problem. The master thread establishes a plurality of solver threads, each solver thread having an initial solution state that is identical to a first solution state of the master thread, and a plurality of cloned planning entity objects that are clones of a plurality of planning entity objects. The master thread communicates a first plurality of temporary incremental state changes to the plurality of solver threads that alters the initial solution state of each solver thread to a different solution state. The master thread receives, from each respective solver thread of the plurality of solver threads, a first score associated with the different solution state of the respective solver thread.