Program Generation Techniques Research Articles

Fuzzing channel-based concurrency runtimes using types and effects

Modern programming languages support concurrent programming based on channels and processes. Channels enable synchronous and asynchronous message-passing between independent light-weight processes making it easy to express common concurrency patterns. The implementation of channels and processes in compilers and language runtimes is a difficult task that relies heavily on traditional and error-prone low-level concurrency primitives, raising concerns about correctness and reliability. In this paper, we present an automatic program generation technique to test such programming language implementations. We define a type and effect system for programs that communicate over channels and where every execution is guaranteed to eventually terminate. We can generate and run such programs, and if a program fails to terminate, we have found a bug in the programming language implementation. We implement such an automatic program generator and apply it to Go, Kotlin, Crystal, and Flix. We find two new bugs in Flix, and reproduce two bugs; one in Crystal and one in Kotlin.

Design Validation of Multithreaded Processors Using Threads Evolution

Within the design arena of modern devices based on cutting-edge processor cores, the availability of effective verification, validation and test methodologies able to work on high-level descriptions of processor cores represents an interesting advantage, since it can dramatically reduce the overall time for design and manufacturing, while improving yield and quality. In this paper we propose a semi-automatic test program generation technique able to target modules in modern computer architectures that implement the multithreading paradigm. The methodology starts from high level descriptions of processor cores and using an incremental multi-run approach produces, with very limited manual intervention, a test set able to maximize verification metrics. Experimental results gathered on a couple of real complex designs (the OpenSPARC™ T1 and T2) show the effectiveness of the proposed methodology.

Application of program generation technology in solving heat and flow problems

Based on a new DIY concept for software development, an automatic program-generating technology attached on a software system called as Finite Element Program Generator (FEPG) provides a platform of developing programs, through which a scientific researcher can submit his special physico-mathematical problem to the system in a more direct and convenient way for solution. For solving flow and heat problems by using finite element method, the stabilization technologies and fraction-step methods are adopted to overcome the numerical difficulties caused mainly due to the dominated convection. A couple of benchmark problems are given in this paper as examples to illustrate the usage and the superiority of the automatic program generation technique, including the flow in a lid-driven cavity, the starting flow in a circular pipe, the natural convection in a square cavity, and the flow past a circular cylinder, etc. They are also shown as the verification of the algorithms.

Synthesizing efficient out-of-core programs for block recursive algorithms using block-cyclic data distributions

In this paper, we present a framework for synthesizing I/O efficient out-of-core programs for block recursive algorithms, such as the fast Fourier transform (FFT) and block matrix transposition algorithms. Our framework uses an algebraic representation which is based on tensor products and other matrix operations. The programs are optimized for the striped Vitter and Shriver's two-level memory model in which data can be distributed using various cyclic(B) distributions in contrast to the normally used physical track distribution cyclic(B/sub d/), where B/sub d/ is the physical disk block size. We first introduce tensor bases to capture the semantics of block-cyclic data distributions of out-of-core data and also data access patterns to out-of-core data. We then present program generation techniques for tensor products and matrix transposition. We accurately represent the number of parallel I/O operations required for the synthesized programs for tensor products and matrix transposition as a function of tensor bases and data distributions. We introduce an algorithm to determine the data distribution which optimizes the performance of the synthesized programs. Further, we formalize the procedure of synthesizing efficient out-of-core programs for tensor product formulas with various block-cyclic distributions as a dynamic programming problem. We demonstrate the effectiveness of our approach through several examples. We show that the choice of an appropriate data distribution can reduce the number of passes to access out-of-core data by as large as eight times for a tensor product and the dynamic programming approach can largely reduce the number of passes to access out-of-core data for the overall tensor product formulas.

A meta-environment for generating programming environments

Over the last decade, considerable progress has been made in solving the problems of automatic generation of programming/development environments, given a formal definition of some programming or specification language. In most cases, research has focused on the functionality and efficiency of the generated environments, and, of course, these aspects will ultimately determine the acceptance of environment generators. However, only marginal attention has been paid to the development process of formal language definitions itself. Assuming that the quality of automatically generated environments will be satisfactory within a few years, the development costs of formal language definitions will then become the next limiting factor determining ultimate success and acceptance of environment generators. In this paper we describe the design and implementation of a meta-environment (a development environment for formal language definitions) based on the formalism ASF + SDF. This meta-environment is currently being implemented as part of the Centaur system and is, at least partly, obtained by applying environment generation techniques to the language definition formalism itself. A central problem is providing fully interactive editing of modular language definitions such that modifications made to the language definition during editing can be translated immediately to modifications in the programming environment generated from the original language definition. Therefore, some of the issues addressed are the treatment of formalisms with user-definable syntax and incremental program generation techniques.

A Generalized Approach to Program Generation for Process Control Applications

A software design method is proposed in an attempt to overcome the limitations of current program generation techniques. This has been achieved by means of a general purpose method for control program specification. The latter encompasses two types of specification, describing control program internal structure, as well as real-time behavior, in the context of various types of process control systems (i.e. continuous, sequence and batch process control systems, etc.). This method has been further enhanced by developing facilities for computer-aided design of new software modules to be included in the program generator library. 1.e. a code generator and vet another facility, allowing the user to define and subsequently, use higher-level (composite) modules.

A prime factor FFT algorithm implementation using a program generation technique

This correspondence presents details of a new implementation of the prime factor FFT algorithm (PFA) for computing the discrete Fourier transform (DFT). This implementation applies a program generation technique to the PFA algorithm and saves about 40 percent of the execution time of the conventional one.

From goals to manipulator programs

We describe an approach to robot programming that supports task-oriented specifications of manipulation activities. Plan formation and program generation techniques are used to transform task specifications into executable programs for various robots. The plan formation operates on a database of knowledge about the world to produce the sequence of actions needed to execute the task. The program generation transforms the sequence of actions into an executable program using knowledge about the robot and its control system.

ISMOS: An experimental database-oriented tool generator

A database-oriented tool is such a tool using a Database Management System to facilitate an integrated management of design information. This paper describes automatic database-oriented tool generation. The model-based approach described in this paper uses the Entity Relationship based model for database-oriented tool definition, and a program generation technique for database-oriented tool software generation. A prototype database-oriented tool generator, called ISMOS, has been developed and shown to be practicable by generating several database-oriented tools. Given such experimental results, some claims for advantages of the model-based approach (i.e., Flexibility and cost/time reduction for acquiring a database-oriented tool) are substantiated.

Constructing Programs with a Plan Formation System

This paper describes a robot planning system for constructing manipulator programs from task descriptions. Plan formation and program generation techniques are used to transform task specifications into executable programs. The plan formation operates on a data base of knowledge about the world to produce the sequence of actions needed to execute the task. The program generation transforms the sequence of actions into an executable program, written in MAL, using knowledge about the robot and its control system.