472 research outputs found
Combining Rewriting and Incremental Materialisation Maintenance for Datalog Programs with Equality
Materialisation precomputes all consequences of a set of facts and a datalog
program so that queries can be evaluated directly (i.e., independently from the
program). Rewriting optimises materialisation for datalog programs with
equality by replacing all equal constants with a single representative; and
incremental maintenance algorithms can efficiently update a materialisation for
small changes in the input facts. Both techniques are critical to practical
applicability of datalog systems; however, we are unaware of an approach that
combines rewriting and incremental maintenance. In this paper we present the
first such combination, and we show empirically that it can speed up updates by
several orders of magnitude compared to using either rewriting or incremental
maintenance in isolation.Comment: All proofs contained in the appendix. 7 pages + 4 pages appendix. 7
algorithms and one table with evaluation result
Expressive Stream Reasoning with Laser
An increasing number of use cases require a timely extraction of non-trivial
knowledge from semantically annotated data streams, especially on the Web and
for the Internet of Things (IoT). Often, this extraction requires expressive
reasoning, which is challenging to compute on large streams. We propose Laser,
a new reasoner that supports a pragmatic, non-trivial fragment of the logic
LARS which extends Answer Set Programming (ASP) for streams. At its core, Laser
implements a novel evaluation procedure which annotates formulae to avoid the
re-computation of duplicates at multiple time points. This procedure, combined
with a judicious implementation of the LARS operators, is responsible for
significantly better runtimes than the ones of other state-of-the-art systems
like C-SPARQL and CQELS, or an implementation of LARS which runs on the ASP
solver Clingo. This enables the application of expressive logic-based reasoning
to large streams and opens the door to a wider range of stream reasoning use
cases.Comment: 19 pages, 5 figures. Extended version of accepted paper at ISWC 201
Shared Arrangements: practical inter-query sharing for streaming dataflows
Current systems for data-parallel, incremental processing and view
maintenance over high-rate streams isolate the execution of independent
queries. This creates unwanted redundancy and overhead in the presence of
concurrent incrementally maintained queries: each query must independently
maintain the same indexed state over the same input streams, and new queries
must build this state from scratch before they can begin to emit their first
results. This paper introduces shared arrangements: indexed views of maintained
state that allow concurrent queries to reuse the same in-memory state without
compromising data-parallel performance and scaling. We implement shared
arrangements in a modern stream processor and show order-of-magnitude
improvements in query response time and resource consumption for interactive
queries against high-throughput streams, while also significantly improving
performance in other domains including business analytics, graph processing,
and program analysis
Incremental Evaluation of Rules and its Relationship to Parallelism
Rule interpreters usually start with an initial database and perform the inference procedure in cycles, ending with a final database. In a real time environment it is possible to receive updates to the initial database after the inference procedure has started or even after it has ended. We present an algorithm for incremental maintenance of the deductive database in the presence of such updates. Interestingly, the same algorithm is useful for parallel and distributed rule processing in the following sense. \\'hen the processors evaluating a program operate asynchronously. then they may have different views of the database. The incremental maintenance procedure we present can be used to synchronize these views
Redacted by arXiv
Redacted by arXiv.Comment: This article has been removed by arXiv due a copyright claim by a 3rd
part
Modular Materialisation of Datalog Programs
The semina\"ive algorithm can materialise all consequences of arbitrary
datalog rules, and it also forms the basis for incremental algorithms that
update a materialisation as the input facts change. Certain (combinations of)
rules, however, can be handled much more efficiently using custom algorithms.
To integrate such algorithms into a general reasoning approach that can handle
arbitrary rules, we propose a modular framework for materialisation computation
and its maintenance. We split a datalog program into modules that can be
handled using specialised algorithms, and handle the remaining rules using the
semina\"ive algorithm. We also present two algorithms for computing the
transitive and the symmetric-transitive closure of a relation that can be used
within our framework. Finally, we show empirically that our framework can
handle arbitrary datalog programs while outperforming existing approaches,
often by orders of magnitude.Comment: Accepted at AAAI 201
A Differential Datalog Interpreter
The core reasoning task for datalog engines is materialization, the
evaluation of a datalog program over a database alongside its physical
incorporation into the database itself. The de-facto method of computing it, is
through the recursive application of inference rules. Due to it being a costly
operation, it is a must for datalog engines to provide incremental
materialization, that is, to adjust the computation to new data, instead of
restarting from scratch. One of the major caveats, is that deleting data is
notoriously more involved than adding, since one has to take into account all
possible data that has been entailed from what is being deleted. Differential
Dataflow is a computational model that provides efficient incremental
maintenance, notoriously with equal performance between additions and
deletions, and work distribution, of iterative dataflows. In this paper we
investigate the performance of materialization with three reference datalog
implementations, out of which one is built on top of a lightweight relational
engine, and the two others are differential-dataflow and non-differential
versions of the same rewrite algorithm, with the same optimizations
- …