Automatic generation of parallel programs for mimd computer systems

Conclusion The use of linear-time automatic algorithms for sequential program parallelization substantially expands the scope of MCS. Parallel implementation is justified from time considerations even when the application program is executed only a few times without modification (only once when the macrooperation system is introduced), i.e., for frequently reprogrammed jobs. Only linear-time parallel-branch algorithms ensure that the execution frequency of the application program that justifies parallel implementation is independent of the number of statements in the program and allow the size (computational complexity) of the macrooperations treated as parallelization units to be varied between wide limits both in the direction of greater aggregation and in the direction of refinement. At the same time, the linear-time parallel-program generation algorithms proposed in this paper produce programs of acceptable quality. Translated from Kibernetika i Sistemnyi Analiz, No. 5, pp. 170–179, September–October, 1995.     

基于攻击图的渗透测试方案自动生成方法

为满足网络安全管理需要,提出一种新的渗透测试方案自动生成方法。该方法利用被测试目标网络脆弱点间的逻辑关系,结合原子攻击知识库,通过前向广度优先搜索策略产生渗透攻击图,然后深度优先遍历渗透攻击图生成渗透测试方案,并基于该方法设计实现渗透测试预案自动生成原型系统。实例表明该方法能够有效生成可行的渗透测试方案。     

Automatic evolution of programs for procedural generation of terrains for video games

Nowadays the video game industry is facing a big challenge to keep costs under control as games become bigger and more complex. Creation of game content, such as character models, maps, levels, textures, sound effects and so on, represent a big slice of total game production cost. Hence, the video game industry is increasingly turning to procedural content generation to amplify the cost-effectiveness of the efforts of video game designers. However, procedural methods for automated content generation are difficult to create and parametrize. In this work we study a genetic programming-based procedural content technique to generate procedural terrains that do not require parametrization, thus, allowing to save time and help reducing production costs. Generated procedural terrains present aesthetic appeal; however, unlike most techniques involving aesthetic, our approach does not require a human to perform the evaluation. Instead, the search is guided by the weighted sum of two morphological metrics: terrain accessibility and obstacle edge length. The combination of the two metrics allowed us to find a wide range of fit terrains that present more scattered obstacles in different locations than our previous approach with a single metric. Procedural terrains produced by this technique are already in use in a real video game.     

Automatic generation of path covers based on the control flowanalysis of computer programs

Branch testing a program involves generating a set of paths that will cover every arc in the program flowgraph, called a path cover, and finding a set of program inputs that will execute every path in the path cover. This paper presents a generalized algorithm that finds a path cover for a given program flowgraph. The analysis is conducted on a reduced flowgraph, called a ddgraph, and uses graph theoretic principles differently than previous approaches. In particular, the relations of dominance and implication which form two trees of the arcs of the ddgraph are exploited. These relations make it possible to identify a subset of ddgraph arcs, called unconstrained arcs, having the property that a set of paths exercising all the unconstrained arcs also cover all the arcs in the ddgraph. In fact, the algorithm has been designed to cover all the unconstrained arcs of a given ddgraph: the paths are derived one at a time, each path covering at least one as yet uncovered unconstrained arc. The greatest merits of the algorithm are its simplicity and its flexibility. It consists in just visiting recursively in combination the dominator and the implied trees, and is flexible in the sense that it can derive a path cover to satisfy different requirements, according to the strategy adopted for the selection of the unconstrained arc to be covered at each recursive iteration. This feature of the algorithm can be employed to address the problem of infeasible paths, by adopting the most suitable selection strategy for the problem at hand. Embedding of the algorithm into a software analysis and testing tool is recommended     

Automatic verification of functional programs

We propose an approach to verification of functional programs based on an example of methods and tools developed in functional programming. The program verification procedures and tools developed in the framework of this approach are described.Translated from Kibernetika, No. 4, pp. 30–39, July–August, 1990.     

Automatic form generation

The Acuity project, in support of a collaborative brain‐tumor research effort, provides WWW‐based input forms implemented as Java applets for updating a WWW‐accessible database. The continuing need to develop new, but closely related, input forms motivated the design and implementation of the Acuity Form Generator (AFG), an automatic form‐generation tool. This paper documents the AFG technology. Copyright © 2002 John Wiley & Sons, Ltd.     

Automatic Test Suite generation

A Test Suite (TS) is typically a collection of Natural Language sentences against which the coverage of a Natural Language Processing system can be evaluated. We describe a method by which such suites can be produced automatically, involving a modification and extension of the Definite Clause Grammar formalism, and describe some of the advantages of the method over the traditional method of manual construction.     

Automatic generation of interlocking shapes

This paper describes methods of automatically generating interlocking shapes on a plane surface. Each shape will nest perfectly (without gaps) when it is repeated over a flat surface according to the stated mathematical rules. Symmetry is the key to these shapes. Interlocking shapes can be used in metal stamping, flame cutting, and packaging to conserve material.There are nine principal types of interlocking shapes. Linear methods of generating all of them are presented. Every shape generated is scrap-free. Furthermore, every possible interlocking shape can be generated by one of the nine methods. An actual computer program using any of the methods would consist of four parts: (1) vertex computation, (2) line input, (3) shape generation, and (4) duplication. Nine computer programs have been written to test the algorithms. The programs are in FORTRAN with subroutines supplied by the Graphics Compatibility System (GCS, developed by the U.S. Military Academy). The programs interact with the user on a Tektronix 4010 terminal and they assume no particular mathematical knowledge from the user.     

Automatic generation of tourist brochures

We present a novel framework for the automatic generation of tourist brochures that include routing instructions and additional information presented in the form of so‐called detail lenses. The first contribution of this paper is the automatic creation of layouts for the brochures. Our approach is based on the minimization of an energy function that combines multiple goals: positioning of the lenses as close as possible to the corresponding region shown in an overview map, keeping the number of lenses low, and an efficient numbering of the lenses. The second contribution is a route‐aware simplification of the graph of streets used for traveling between the points of interest (POIs). This is done by reducing the graph consisting of all shortest paths through the minimization of an energy function. The output is a subset of street segments that enable traveling between all the POIs without considerable detours, while at the same time guaranteeing a clutter‐free visualization.     

Automatic generation of make dependencies

In the UNIX environment, it is standard practice to use the make program to keep a system of interrelated modules up to date. When text files contain so-called include statements referring to additional text files whose contents are to replace the statements, it soon becomes impractical, in a growing system, to manually maintain all make dependencies implied by these references. Therefore, the dependencies are often generated automatically from extracted include statements by various methods. However, the methods we have seen in use are too simplistic and either generate the wrong set of dependencies, or give only partial support. This paper describes an algorithm that can be used to generate make dependencies implied by include statements from a wide class of include mechanisms.     

Automatic mode inference for logic programs

In general, logic programs are undirected, i.e., there is no concept of “input” and “output” arguments to a procedure. An argument may be used either as an input or as an output argument, and programs may be executed either in a “forward” direction or in a “backward” direction. However, it is often the case that in a given program, a predicate is used with some of its arguments used consistently as input arguments and others as output arguments. Such mode information can be used by a compiler to effect various optimizations. This paper considers the problem of automatically inferring the models of the predicates in a program. The dataflow analysis we use is more powerful than approaches relying on syntactic characteristics of programs. Our work differs from that of Mellish in that (1) we give a sound and efficient treatment of variable aliasing in mode inference; (2) by propagating instantiation information using state transformations rather than through dependencies between variables, we achieve greater precision in the treatment of unification, e.g. through =/2; and (3) we describe an efficient implementation based on the dynamic generation of customized mode interpreters. Several optimizations to improve the performance of the mode inference algorithm are described, as are various program optimizations based on mode information.     

一个网格环境下基于分块的混合型自调度算法

针对当前已有自调度算法在网格环境中存在负载不平衡、参数值难以确定的问题,结合网格自身的特点提出一种新的基于分块的混合型自调度算法CHSS。该算法吸取了可以人为确定块大小及根据性能值分配的思想,提出在分配的每一阶段都考虑子节点性能的方法。实验证明,该算法比现有自调度算法在总计算时间上有了大大的缩短并且能取得更好的负载平衡。     

Cobol generation of source programs and reports

SURGE, a COBOL pre-processor for the machine generation of source programs, is described. The article presents the coding procedure by which the user communicates with SURGE, and briefly introduces the general logic of both the pre-processor and generated programs. The main capabilities of SURGE are described as file sorting, selective retrieval and tabular report preparation, including multiple levels of totals and a capability for certain other kinds of computation. Non-proprietary and relatively machine-independent, this package appears to reduce the need for hand-crafted COBOL programs and to be remarkably easy to learn and use. It is suggested that SURGE also may offer a suitable prototype for extending the concept of source-program generation to other goals such as file updating and the production of FORTRAN programs.     

Automatic performance debugging of SPMD-style parallel programs

Automatic performance debugging of parallel applications includes two main steps: locating performance bottlenecks and uncovering their root causes for performance optimization. Previous work fails to resolve this challenging issue in two ways: first, several previous efforts automate locating bottlenecks, but present results in a confined way that only identifies performance problems with a priori knowledge; second, several tools take exploratory or confirmatory data analysis to automatically discover relevant performance data relationships, but these efforts do not focus on locating performance bottlenecks or uncovering their root causes.The simple program and multiple data (SPMD) programming model is widely used for both high performance computing and Cloud computing. In this paper, we design and implement an innovative system, AutoAnalyzer, that automates the process of debugging performance problems of SPMD-style parallel programs, including data collection, performance behavior analysis, locating bottlenecks, and uncovering their root causes. AutoAnalyzer is unique in terms of two features: first, without any prior knowledge, it automatically locates bottlenecks and uncovers their root causes for performance optimization; second, it is lightweight in terms of the size of performance data to be collected and analyzed. Our contributions are three-fold: first, we propose two effective clustering algorithms to investigate the existence of performance bottlenecks that cause process behavior dissimilarity or code region behavior disparity, respectively; meanwhile, we present two searching algorithms to locate bottlenecks; second, on the basis of the rough set theory, we propose an innovative approach to automatically uncover root causes of bottlenecks; third, on the cluster systems with two different configurations, we use two production applications, written in Fortran 77, and one open source code—MPIBZIP2 (http://compression.ca/mpibzip2/), written in C++, to verify the effectiveness and correctness of our methods. For three applications, we also propose an experimental approach to investigating the effects of different metrics on locating bottlenecks.     

Goal-oriented test data generation for pointer programs

Automatic test data generation leads to the identification of input values on which a selected path or a selected branch is executed within a program (path-oriented vs. goal-oriented methods). In both cases, several approaches based on constraint solving exist, but in the presence of pointer variables only path-oriented methods have been proposed. Pointers are responsible for the existence of conditional aliasing problems that usually provoke the failure of the goal-oriented test data generation process. In this paper, we propose an overall constraint-based method that exploits the results of an intraprocedural points-to analysis and provides two specific constraint combinators for automatically generating goal-oriented test data. This approach correctly handles multi-levels stack-directed pointers that are mainly used in C programs. The method has been fully implemented in the test data generation tool INKA and first experiences in applying it to a variety of existing programs are presented.     

Automatic generation of process flow diagrams

An algorithm which automates the generation of process flow diagrams for distributed programs has been developed. The algorithm maps a graph specification to a graph diagram. The implementation of a graphics monitor uses process flow diagrams to monitor execution of distributed programs on an experimental multiprocessor system. Process states are superimposed onto process flow diagrams to enhance visualization of the execution sequence. Techniques of clustering and unclustering processes are also described.     

非线性循环不变式的自动生成

提出了一个自动生成非线性循环不变式的算法。循环不变式可以表示成一个带参数的多项式的形式,根据断言的归纳特性,将循环不变式的生成问题转变成一个约束求解问题,这个约束求解问题的每个解对应于一个循环不变式,如果约束求解问题仅有零解,则说明不存在该参数多项式形式的循环不变式。该算法在Maple中得到了实现,并通过一些实例说明了该算法的有效性。