Parallel Logical Rule Materialisation in RDF Databases
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing methods for materializing logical rules in RDF databases are inefficient due to limitations in parallel processing and memory usage, particularly when handling equality predicates, leading to suboptimal performance in deriving new triples and answering queries.
Innovation Solution
A computer-implemented method where parallel processing threads receive logical facts, apply rules to derive new facts, and manage equality predicates by selecting representative constants, allowing for efficient parallel execution and storage in a structured computer memory format that minimizes concurrency issues.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If the seminaïve algorithm is used for materialisation, then completeness of derived triples is improved, but parallel processing efficiency deteriorates due to threads waiting for others to complete
Solution Approach 1:
The patent divides the materialisation process into independent segments that can be processed in parallel. Each thread processes a subset of rules or facts independently, using local buffers to store intermediate results. This segmentation eliminates the need for threads to wait for each other while maintaining completeness through systematic coverage of all rule-fact combinations.
Solution Approach 2:
The patent introduces a new dimension of parallelism by organizing the computation space differently. Instead of having threads sequentially process rules in a single dimension, the system distributes work across multiple dimensions (different rule subsets, different fact subsets, different processing stages), allowing simultaneous execution without interference.
2Reliability
If traditional materialisation methods are used, then correctness of logical derivation is improved, but memory usage efficiency deteriorates due to inability to support parallel processing
Solution Approach 1:
The patent segments the global knowledge base into multiple partitions, each processed by dedicated threads with local memory buffers. This segmentation reduces the memory footprint per thread while maintaining access to the complete logical system through controlled synchronization points, improving overall memory efficiency without sacrificing derivation correctness.
Solution Approach 2:
Each processing thread operates with locally optimized data structures and memory buffers tailored to its specific subset of rules and facts. This local optimization allows efficient memory utilization for each thread's workload while the system as a whole maintains correctness through coordinated access to shared structures.
3Reliability
If equality predicates are handled using traditional rewriting techniques, then handling of owl:sameAs predicates is improved, but parallel processing capability deteriorates
Solution Approach 1:
The patent performs preliminary identification and grouping of equality predicates (owl:sameAs) before the main parallel processing begins. Equality chains are pre-computed and stored in efficient data structures that can be quickly accessed during parallel rule evaluation, allowing threads to handle equality constraints independently without interfering with each other's execution.
Data Source
AI summary
A computer-implemented method of providing a materialisation of a set of logical rules on a logical database comprising a set of logical facts. Each of a plurality of parallel processing threads performs the following steps. A logical fact that has not previously been received by any thread is received by the thread. By applying any of the logical rules to the received logical fact and/or any of the logical facts received by any thread prior to the received logical fact, the thread determines whether a new logical fact is implied, and if so the new logical fact is added to the set of logical facts. The thread then repeats the above steps on any further logical facts in the set of logical facts that have not previously been received by any thread. When all threads are waiting for a new logical fact, the method has completed.