Partial Evaluation Techniques Research Articles

A partial evaluation framework for order-sorted equational programs modulo axioms

Partial evaluation is a powerful and general program optimization technique with many successful applications. Existing PE schemes do not apply to expressive rule-based languages like Maude, CafeOBJ, OBJ, ASF+SDF, and ELAN, which support: 1) rich type structures with sorts, subsorts, and overloading; and 2) equational rewriting modulo various combinations of axioms such as associativity, commutativity, and identity. In this paper, we develop the new foundations needed and illustrate the key concepts by showing how they apply to partial evaluation of expressive programs written in Maude. Our partial evaluation scheme is based on an automatic unfolding algorithm that computes term variants and relies on high-performance order-sorted equational least general generalization and order-sorted equational homeomorphic embedding algorithms for ensuring termination. We show that our partial evaluation technique is sound and complete for convergent rewrite theories that may contain various combinations of associativity, commutativity, and/or identity axioms for different binary operators. We demonstrate the effectiveness of Maude's automatic partial evaluator, Victoria, on several examples where it shows significant speed-ups.

Концептуальний підхід до вибору пріоритетних напрямів розвитку спроможностей Збройних Сил України та інших складових сил оборони

Концептуальний підхід до вибору пріоритетних напрямів розвитку спроможностей Збройних Сил України та інших складових сил оборони

Jones-optimal partial evaluation by specialization-safe normalization

We present partial evaluation by specialization-safe normalization, a novel partial evaluation technique that is Jones-optimal, that can be self-applied to achieve the Futamura projections and that can be type-checked to ensure it always generates code with the correct type. Jones-optimality is the gold-standard for nontrivial partial evaluation and guarantees that a specializer can remove an entire layer of interpretation. We achieve Jones-optimality by using a novel affine-variable static analysis that directs specialization-safe normalization to always decrease a program’s runtime. We demonstrate the robustness of our approach by showing Jones-optimality in a variety of settings. We have formally proved that our partial evaluator is Jones-optimal for call-by-value reduction, and we have experimentally shown that it is Jones-optimal for call-by-value, normal-order, and memoized normal-order. Each of our experiments tests Jones-optimality with three different self-interpreters. We implemented our partial evaluator in F ω µ i , a recent language for typed self-applicable meta-programming. It is the first Jones-optimal and self-applicable partial evaluator whose type guarantees that it always generates type-correct code.

Temporal constrained objects: Application and implementation

We present a novel programming concept called temporal constrained objects for modeling of dynamic systems. It is an extension of the paradigm of constrained objects which provides a principled approach to modeling complex engineering systems based upon two main principles: a compositional specification of the structure of the system, using objects, and a declarative specification of its behavior, using constraints. A novel feature of temporal constrained objects is the series variable, the sequence of whose values is determined by constraints that include metric temporal operators. The emergent behavior of a dynamic system is determined through a process of time-based simulation and constraint satisfaction at each step. Each class definition for a temporal constrained object is translated into a Prolog rule with constraint-solving capability. In order to improve the performance for long simulations, a partial evaluation technique is adopted for optimized code generation. This paper describes the syntax of a language called TCOB along with several examples, our objective being to demonstrate the benefits of the programming paradigm. TCOB has been implemented and all examples presented in this paper were tested using this implementation. An overview of the translation as well as partial execution and its performance improvements are presented in the paper.

A Feature Extraction Method Using Empirical Mode Decomposition and Histogram Modeling for Robust Bearing Fault Diagnosis

This paper proposes a method using empirical mode decomposition (EMD) and histogram modeling for bearing defects of a low-speed rotational induction motor. The proposed method minimizes signal distortion caused by noise using the EMD and conducts histogram envelope modeling by normalizing a signal. Then, the method extracts and selects unique features of each fault using partial autocorrelation coefficients (PARCOR) and distance evaluation technique (DET). Using the extracted features as inputs, support vector Received(July 10, 2014), Review request(July 11, 2014), Review Result(1st: July 24, 2014) Accepted(December 10, 2014) Publish(December 31, 2014) 689-749 School of Electrical Engineering, University of Ulsan, Nam-gu, Ulsan, Korea. email: fahmid.farid@gmail.com 689-749 School of Electrical Engineering, University of Ulsan, Nam-gu, Ulsan, Korea. email: nasha0339@gmail.com (Corresponding Author) 689-749 School of Electrical Engineering, University of Ulsan, Nam-gu, Ulsan, Korea. email: jmkim07@ulsan.ac.kr * This research was supported by Basic Science Research Program through the National Research Foundation of Korea(NRF) funded by the Ministry of Education, Science and Technology(NRF-2012R1A1A2043644) A Feature Extraction Method Using Empirical Mode Decomposition and Histogram Modeling for Robust Bearing Fault Diagnosis Copyright c 2014 SERSC 282 regression (SVR) classifies inner, outer, and roller faults of a bearing. For the optimal classification performance, we vary a variable of the kernel function of SVR ranging from 0.01 to 1.0 and the number of features ranging from 2 to 250. Experimental results indicate that the proposed method having a parameter of 0.55 and 45 features outperforms conventional fault classification methods, yielding an average of 95% classification performance.

Asynchronous adaptive optimisation for generic data‐parallel array programming

SUMMARYProgramming productivity very much depends on the availability of basic building blocks that can be reused for a wide range of application scenarios and the ability to define rich abstraction hierarchies. Driven by the aim for increased reuse, such basic building blocks tend to become more and more generic in their specification; structural as well as behavioural properties are turned into parameters that are passed on to lower layers of abstraction where eventually a differentiation is being made. In the context of array programming, such properties are typically array ranks (number of axes/dimensions) and array shapes (number of elements along each axis/dimension). This allows for abstract definitions of operations such as element‐wise additions, concatenations, rotations, and so on, which jointly enable a very high‐level compositional style of programming, similar to, for instance, MATLAB. However, such a generic programming style generally comes at a price in terms of runtime overheads when compared against tailor‐made low‐level implementations. Additional layers of abstraction as well as the lack of hard‐coded structural properties often inhibits optimisations that are obvious otherwise. Although complex static compiler analyses and transformations such as partial evaluations can ameliorate the situation to quite some extent, there are cases, where the required level of information is not available until runtime. In this paper, we propose to shift part of the optimisation process into the runtime of applications. Triggered by some runtime observation, the compiler asynchronously applies partial evaluation techniques to frequently used program parts and dynamically replaces initial program fragments by more specialised ones through dynamic re‐linking. In contrast to many existing approaches, we suggest this optimisation to be done in a rather non‐intrusive, decoupled way. We use a full‐fledged compiler that is run on a separate core. This measure enables us to run the compiler on its highest optimisation‐level, which requires non‐negligible compilation times for our optimisations. We use the compiler's type system to identify the potential dynamic optimisations. And we use the host language's module system as a facilitator for the dynamic code modifications. We present the architecture and implementation of an adaptive compilation framework for Single Assignment C, a data‐parallel array programming language. Single Assignment C advocates shape‐generic and rank‐generic programming with arrays. A sophisticated, highly optimising compiler technology nevertheless achieves competitive runtime performance. We demonstrate the suitability of our approach to achieve consistently high performance independent of the static availability of array properties by means of several experiments based on a highly generic formulation of rank‐invariant convolution as a case study. Copyright © 2011 John Wiley & Sons, Ltd.

A self‐applicable online partial evaluator for recursive flowchart languages

SUMMARYThis paper describes a self‐applicable online partial evaluator for a flowchart language with recursive calls. Self‐application of the partial evaluator yields generating extensions that are as efficient as those reported in the literature for offline partial evaluation. This result is remarkable because it has been assumed that online partial evaluation techniques unavoidably lead to inefficient and overgeneralized generating extensions. The purpose of this paper is not to determine which kind of partial evaluation is better, but to show how the problem can be solved by recursive polyvariant specialization. The design of the self‐applicable online partial evaluator is based on a number of known techniques, but by combining them in a new way this result can be produced. The partial evaluator, its techniques, and its implementation are presented in full. Self‐application according to all three Futamura projections is demonstrated. The complete bootstrap of a compiler generator from a partial evaluator is also reported. Copyright © 2011 John Wiley & Sons, Ltd.

ChemInform Abstract: Intergrating Theorem Proving and Partial Evaluation Techniques for Organic Synthesis and Teaching

ChemInform is a weekly Abstracting Service, delivering concise information at a glance that was extracted from about 100 leading journals. To access a ChemInform Abstract of an article which was published elsewhere, please select a “Full Text” option. The original article is trackable via the “References” option.

A General VNS heuristic for the traveling salesman problem with time windows

This paper presents a General Variable Neighborhood Search (GVNS) heuristic for the Traveling Salesman Problem with Time Windows (TSPTW). The heuristic is composed by both constructive and optimization stages. In the first stage, the heuristic constructs a feasible solution using VNS, and in the optimization stage the heuristic improves the feasible solution with a General VNS heuristic. Both constructive and optimization stages take advantage of elimination tests, partial neighbor evaluation and neighborhood partitioning techniques. Experimental results show that this approach is efficient, reducing significantly the computation time and improving some best known results from the literature.

Scalable processing of snapshot and continuous nearest-neighbor queries over one-dimensional uncertain data

In several emerging and important applications, such as location-based services, sensor monitoring and biological databases, the values of the data items are inherently imprecise. A useful query class for these data is the Probabilistic Nearest-Neighbor Query (PNN), which yields the IDs of objects for being the closest neighbor of a query point, together with the objects’ probability values. Previous studies showed that this query takes a long time to evaluate. To address this problem, we propose the Constrained Nearest-Neighbor Query (C-PNN), which returns the IDs of objects whose probabilities are higher than some threshold, with a given error bound in the answers. We show that the C-PNN can be answered efficiently with verifiers. These are methods that derive the lower and upper bounds of answer probabilities, so that an object can be quickly decided on whether it should be included in the answer. We design five verifiers, which can be used on uncertain data with arbitrary probability density functions. We further develop a partial evaluation technique, so that a user can obtain some answers quickly, without waiting for the whole query evaluation process to be completed (which may incur a high response time). In addition, we examine the maintenance of a long-standing, or continuous C-PNN query. This query requires any update to be applied to the result immediately, in order to reflect the changes to the database values (e.g., due to the change of the location of a moving object). We design an incremental update method based on previous query answers, in order to reduce the amount of I/O and CPU cost in maintaining the correctness of the answers to such a query. Performance evaluation on realistic datasets show that our methods are capable of yielding timely and accurate results.

Approximate algorithms for credal networks with binary variables

This paper presents a family of algorithms for approximate inference in credal networks (that is, models based on directed acyclic graphs and set-valued probabilities) that contain only binary variables. Such networks can represent incomplete or vague beliefs, lack of data, and disagreements among experts; they can also encode models based on belief functions and possibilistic measures. All algorithms for approximate inference in this paper rely on exact inferences in credal networks based on polytrees with binary variables, as these inferences have polynomial complexity. We are inspired by approximate algorithms for Bayesian networks; thus the Loopy 2U algorithm resembles Loopy Belief Propagation, while the Iterated Partial Evaluation and Structured Variational 2U algorithms are, respectively, based on Localized Partial Evaluation and variational techniques.

Partial evaluation technique for distributed image processing

In this paper, a partial evaluation technique to reduce communication costs of distributed image processing is presented. It combines application of incomplete structures and partial evaluation together with classical program optimization such as constant-propagation, loop unrolling and dead-code elimination. Through a detailed performance analysis, we establish conditions under which the technique is beneficial.

Efficient Reductants Calculi using Partial Evaluation Techniques with Thresholding

Reductants are a useful theoretical tool introduced for proving correctness properties in the context of generalized annotated logic programming. This concept was adapted to the more recent and flexible framework of multi-adjoint logic programming for solving a problem of incompleteness that arises when working with some lattices. In order to be complete, multi-adjoint logic programs must be extended with their set of reductants. In general, the notion of reductant may introduce an important efficiency drawback. In this work we provide a more refined version of this concept that we call PE-reductant, by using (threshold) partial evaluation techniques. Our proposal is intended to be semantically equivalent to the classical notion of reductant, and improves previous approaches at least in the following two efficiency criteria. Firstly, using the new definition of reductant, we can obtain computed answers for a given goal with a lesser computational effort than by using its precedent ones. Secondly, the proper construction of a reductant by means of partial evaluation methods, is drastically improved after introducing thresholding techniques which dynamically reduce the size of the underlying unfolding trees.

A model‐driven approach to automatic conversion of physical units

AbstractWhen physical quantities are used in programs they are typically represented as raw numbers, with the units in which they were measured only being given in comments, if at all. This can lead to errors from the use of dimensionally inconsistent expressions, or the comparison of two quantities of the same dimension but measured in different units, which are not discovered until run time. Any program working with the physical world has this issue, with scientific modelling being a major application. Implementors of models have the time‐consuming and error‐prone task of adding in dynamic units checks and conversions manually. Most existing programming languages do not provide support for representing units explicitly (although extensions to some have been proposed). With the advent of domain‐specific modelling languages, incorporating code generation techniques, we propose checking physical units at the level of the modelling language, removing the need for such a support in the underlying implementation language. We present our work in the context of one such modelling language: CellML, developed at the University of Auckland with a focus on modelling biological systems. We have developed an intuitive algorithm for performing automatic conversions between quantities measured in different units. It both requires fewer conversion operations than current approaches and makes more sensible choices about which quantities to convert. Uniquely, by using partial evaluation techniques it is also capable of dealing robustly with quantities raised to arbitrary powers, even where the exponent is given by an expression. We demonstrate our algorithm on various examples. Copyright © 2007 John Wiley & Sons, Ltd.

Derivation of Efficient Logic Programs by Specialization and Reduction of Nondeterminism

Program specialization is a program transformation methodology which improves program efficiency by exploiting the information about the input data which are available at compile time. We show that current techniques for program specialization based on partial evaluation do not perform well on nondeterministic logic programs. We then consider a set of transformation rules which extend the ones used for partial evaluation, and we propose a strategy for guiding the application of these extended rules so to derive very efficient specialized programs. The efficiency improvements which sometimes are exponential, are due to the reduction of nondeterminism and to the fact that the computations which are performed by the initial programs in different branches of the computation trees, are performed by the specialized programs within single branches. In order to reduce nondeterminism we also make use of mode information for guiding the unfolding process. To exemplify our technique, we show that we can automatically derive very efficient matching programs and parsers for regular languages. The derivations we have performed could not have been done by previously known partial evaluation techniques.

Abstract specialization and its applications

The aim of program specialization is to optimize programs by exploiting certain knowledge about the context in which the program will execute. There exist many program manipulation techniques which allow specializing the program in different ways. Among them, one of the best known techniques is partial evaluation , often referred to simply as program specialization, which optimizes programs by specializing them for (partially) known input data. In this work we describe abstract specialization , a technique whose main features are: (1) specialization is performed with respect to "abstract" values rather than "concrete" ones, and (2) abstract interpretation rather than standard interpretation of the program is used in order to propagate information about execution states. The concept of abstract specialization is at the heart of the specialization system in CiaoPP, the Ciao system preprocessor. In this paper we present a unifying view of the different specialization techniques used in CiaoPP and discuss their potential applications by means of examples. The applications discussed include program parallelization, optimization of dynamic scheduling (concurrency), and integration of partial evaluation techniques.

Program specialization for execution monitoring

Execution monitoring is a proven tool for securing program execution and to enforce safety properties on applets and mobile code, in particular. Inlining monitoring tools perform their task by inserting certain run-time checks into the monitored application before executing it. For efficiency reasons, they attempt to insert as few checks as possible using techniques ranging from simple ad hoc optimizations to theorem proving. Partial evaluation is a powerful tool for specifying and implementing program transformations. The present work demonstrates that standard partial evaluation techniques are sufficient to transform an interpreter equipped with monitoring code into a non-standard compiler. This compiler generates application code, which contains the inlined monitoring code. If the monitor is enforcing a security policy, then the result is a secured application code. If the policy is defined using a security automaton, then the transformation can elide many run-time checks by using abstract interpretation. Our approach relies on proper staging of the monitoring interpreter. The transformation runs in linear time, produces code linear in the size of the original program, and is guaranteed not to duplicate incoming code.

Partial evaluation of pattern matching in strings, revisited

Specialization of a string matcher is a canonical example of partial evaluation. A naive implementation of a string matcher repeatedly matches a pattern against every substring of the data string; this operation should intuitively benefit from specializing the matcher with respect to the pattern. In practice, however, producing an efficient implementation by performing this specialization using standard partial-evaluation techniques requires non-trivial binding-time improvements. Starting with a naive matcher, we thus present a derivation of such a binding-time improved string matcher. We show that specialization with respect to a pattern yields a matcher with code size linear in the length of the pattern and a running time independent of the length of the pattern and linear in the length of the data string. We then consider several variants of matchers that specialize well, amongst them the first such matcher presented in the literature, and we demonstrate how variants can be derived from each other systematically.

Facile

Architectural simulators are essential tools for computer architecture and systems research and development. Simulators, however, are becoming frustratingly slow, because they must now model increasingly complex micro-architectures running realistic workloads. Previously, we developed a technique called fast-forwarding, which applied partial evaluation and mermoization to improve the performance of detailed architectural simulations by as much as an order of magnitude [14]. While writing a detailed processor simulator is difficult, implementing fast-forwarding is even more complex. This paper describes Facile, a domain-specific language for writing detailed, accurate micro-architecture simulators. Architectural descriptions written in Facile can be compiled, using partial evaluation techniques, into fast-forwarding simulators that achieve significant performance improvements with far less programmer effort. Facile and its compiler make this performance-enhancing technique accessible to computer architects.

Partial Evaluation of Pattern Matching in Strings, revisited

Specializing string matchers is a canonical example of partial evaluation.<br /> A naive implementation of a string matcher repeatedly matches a<br />pattern against every substring of the data string; this operation should<br />intuitively benefit from specializing the matcher with respect to the pattern.<br /> In practice, however, producing an efficient implementation by <br />performing this specialization using standard partial-evaluation techniques<br />has been found to require non-trivial binding-time improvements. Starting<br /> with a naive matcher, we thus present a derivation of a binding-time<br />improved string matcher. We prove its correctness and show that specialization<br /> with respect to a pattern yields a matcher with code size linear<br />in the length of the pattern and running time linear in the length of its<br />input. We then consider several variants of matchers that specialize well,<br />amongst them the first such matcher presented in the literature, and we<br />demonstrate how variants can be derived from each other systematically.