Concurrent and Local Evaluation of Normal Programs

Abstract

Abstract. Tabled evaluations can incorporate a number of features, including tabled negation, reduction with respect to the well-founded model, tabled constraints and answer subsumption. Many of these features are most efficiently evaluated using the Local evaluation strategy, which fully evaluates each mutually dependent set of tabled subgoals before returning answers to other subgoals outside of that set. In this paper, we introduce a formalism, Concurrent Local SLG by which multiple threads of computation concurrently perform Local evaluation of the well-founded semantics, and which is a framework for multi-threaded tabling in the XSB system. We prove several properties of Local evaluation within single-threaded tabled computation. We then extend SLG to a model of concurrency and show that the completeness and complexity of SLG are retained when computed by multiple threads. Finally, we extend Local evaluation to concurrent SLG, and show that the properties of Local evaluation continue to hold under concurrency.This paper provides an operational semantics for a type of concurrent TLP that relies on a scheduling strategy called Local evaluation [4]. The model of concurrency adopted is one in which threads of computation execute separate subgoals while sharing completed tables. The main idea behind Local evaluation is that it fully evaluates a single mutually dependent set of tabled subgoals before performing operations (such as returning answers) to subgoals outside of that set. Experiments in several implementations have shown that Local evaluation utilizes space efficiently (see e.g. [4,10]) and as a result it has been implemented for several Prologs.Another feature of Local evaluation is shown in an example in [4] in which tabling was used to compute the shortest path between two nodes. When Local evaluation was used the shortest path could be computed in a time proportional to the number of nodes in the graph, while if a non-Local scheduling strategy was used the time was proportional to the number of paths in the graph -i.e. the time was exponential in the number of nodes. Comparing path lengths to compute a shortest path can be considered as an instance of answer subsumption in which answers are retained and propagated only if they are maximal over a partial order or are a monotonic function of answers so far produced.Using SLG resolution [1] as a basis, this paper presents the following results about concurrent and Local evaluations.-As analysis of Local evaluation in the literature has been mostly empirical, Local SLG evaluation is formally defined in Section 2 and shown complete

Table space designs for implicit and explicit concurrent tabled evaluation

“…For tabling, that means that each evaluation only depends on the computations being performed by the worker itself, i.e., a worker does not need to consume answers from other workers' tables as it can always be the generator for all of its subgoal calls. These are the cases of XSB (Marques and Swift 2008) and Yap (Areias and Rocha 2012b) designs that support explicit concurrent tabled evaluation using threads. In any case, the table space data structures can be either private or partially shared between workers.…”

“…To the best of our knowledge, only the XSB and Yap systems support the combination of tabling with some form of concurrency/parallelism. In XSB, the SLG-WAM execution model was extended with a shared tables design (Marques and Swift 2008) to support explicit concurrent tabled evaluation using threads. It uses a semi-naive approach that, when a set of subgoals computed by different threads is mutually dependent, then a usurpation operation synchronizes threads and a single thread assumes the computation of all subgoals, turning the remaining threads into consumer threads.…”

“…since we got segmentation fault execution errors. From our point of view, XSB's results are a consequence of the usurpation operation (Marques and Swift 2008) that restricts the potential of concurrency to non-mutually dependent sub-computations. As the concurrent versions of the Knapsack and LCS problems create mutual dependent sub-computations, which can be executed in different threads, XSB is actually unable to execute them concurrently.…”

On the Correctness and Efficiency of Lock-Free Expandable Tries for Tabled Logic Programs

“…To the best of our knowledge, XSB and Yap are the unique Prolog systems combining tabling with multi-threading. XSB offers two types of models for supporting multi-threaded tabling: private tables and shared tables [8]. For private tables, each thread keeps its own copy of the table space.…”

A Lock-Free Hash Trie Design for Concurrent Tabled Logic Programs

“…Despite the availability of both multithreading and tabling in some Prolog systems, the efficient implementation of these two features, such that they work together, implies a complex redesign of several components of the underlying engine. XSB was the first Prolog system to combine tabling with multithreading (Marques and Swift 2008). In more recent work (Areias and Rocha 2012b), we have proposed an alternative view to XSB's approach, where each thread views its tables as private but, at the engine level, we use a common table space, i.e., from the thread point of view, the tables are private but, from the implementation point of view, tables are shared among all threads.…”