Flexible scheduling for non-deterministic, and-parallel execution of logic programs

Abstract

We summarise our study of an important (but rarely examined) aspect of parallel execution in logic programming (LP): memory management, and the closely related issue of scheduling. We examine these issues in the context of implicit and-parallelism in nondeterministic programs, because it presents some of the most general problems (see [8] for justifications). This abstract is a highly condensed versión of [8], and the reader is referred to that paper for details. We use the "sub-tree" (or "multi-sequential" approach), where the computation is divided into "chunks" (tasks) which are worked on by individual processing agents (workers) cooperatively in parallel. To retain much of the sequential efficiency of state of the art sequential LP systems while achieving performance improvements through parallelism, each task is executed by the worker in much the same way as in a sequential implementation, except that parallel work can be made available for other idling workers during such execution. Like in sequential LP systems, efficient memory management of parallel LP systems can be achieved by doing stack-based memory management, though parallelism introduces extra complications. Each worker has its own stack, and the stack of a sequential implementation thus becomes a distributed stack, with its state physically distributed across the various workers' stacks, but logically forming a single stack structure. For non-deterministic and-parallelism, where forking and joining of tasks can occur, additional data structures are needed to link and manage the phy sical distributionof the stack. These structures-markers-form the basis of the marker scheme, first introduced in [2]. Essentially, when each worker is working on a task, it uses its stack in much the same way as a sequential implementation would, but when it finishes the task and picks up another task to work on, a marker is allocated onto the stack to sepárate the memory áreas used by the new task from those used by the oíd one and also to logically link and help manage the various sections of stacks used by the tasks. However, as pointed out in [2], the ability of Prolog to perform search, i.e. backtrack and try different alternative solutions, presents special problems for a distributed stack scheme-the problems of "trapped goals" and "garbage slots" (also referred to as "holes" in or-parallel systems): in a sequential system, backtracking causes the stack to shrink in size, and subsequent execution of an alternative causes the stack to grow again. By the same token, in a distributed stack scheme when a task backtracks, the stack section representing the task first shrinks and then grows again. However, because a worker's stack contains all the stack sections of the tasks it executed, the stack section that is being backtracked may notbe at the top of the stack, and such stack sections are "trapped" by the stack sections following it on the worker's stack.

A Segment-Swapping Approach for Executing Trapped Computations

“…In addition, it needs to store a good amount of additional information, which increases memory overhead. Another solution (also suggested in [4,5,18] and developed further and studied in [13]) is to allow public backtracking, i.e., to let an agent perform backtracking over a choicepoint that belongs to the stack set of a different agent. Unfortunately, this solution creates a difference between logical and physical views of the stacks, and adds the complexity of having to manage parallel accesses to the private stacks of each of the agents.…”

Parallel backtracking with answer memoing for independent and-parallelism

“…Several solutions have been proposed for this problem. One of the original proposals uses continuation markers (Hermenegildo 1986;Shen and Hermenegildo 1996) to skip over stacked goals. This is, however, difficult to implement properly and needs to take care of a large number of cases.…”

Parallelizing irregular and pointer-based computations automatically: Perspectives from logic and constraint programming

“…These techniques support, for example, efficient memory recovery during parallel backtracking search. Some interesting examples of these dynamic scheduling and memory management techniques are presented in [37,43,62,64,71] for and-parallelism and in [2,20,32,55,76] for or-parallelism.…”