Source Transformation for Concurrency Analysis

Concurrent programming poses a unique set of problems for quality assurance. These difficulties include the complexities of deadlock, livelock and divergence, which can be extremely difficult to detect and debug. A variety of tools have been developed to assist designers and developers of concurrent applications. Some of these tools, such as VeriSoft, are specific to particular implementation languages, such as C++.The Java Remote Method Invocation (Java RMI) package facilitates the implementation of concurrent applications, including those where processes reside on different hosts and communicate over networks. Unfortunately, it does not relieve the developer from the potential pitfalls of controlling concurrent access to remote objects, and may, in fact, make concurrency problems even more difficult to find.This paper presents an approach that allows the VeriSoft state exploration system to be used to analyze Java RMI programs for deadlock, livelock, divergence, and assertion violations. The system works by transforming Java RMI programs into C++ programs where Java syntax, structure, concurrency and memory management are replaced by C++ equivalents and Java RMI communication has been transformed to VeriSoft C++ inter-process communication. We present the details of this transformation and discuss preliminary results for a number of small examples.     

Genetic Programming-Based Automatic Gait Generation in Joint Space for a Quadruped Robot

This paper introduces a new approach to developing a fast gait for a quadruped robot using genetic programming (GP). Planning gaits for legged robots is a challenging task that requires optimizing parameters in a highly irregular and multi-dimensional space. Several recent approaches have focused on using genetic algorithms (GAs) to generate gaits automatically and have shown significant improvement over previous gait optimization results. Most current GA-based approaches optimize only a small, pre-selected set of parameters, but it is difficult to decide which parameters should be included in the optimization to get the best results. Moreover, the number of pre-selected parameters is at least 10, so it can be relatively difficult to optimize them, given their high degree of interdependence. To overcome these problems of the typical GA-based approach, we have proposed a seemingly more efficient approach that optimizes joint trajectories instead of locus-related parameters in Cartesian space, using GP. Our GP-based method has obtained much-improved results over the GA-based approaches tested in experiments on the Sony AIBO ERS-7 in the Webots environment. The elite archive mechanism is introduced to combat the premature convergence problems in GP and has shown better results than a traditional multi-population approach.     

Implementing interactive applications in C++

This paper presents an object-oriented approach for the implementation of interactive systems. This approach applies the model-view-controller (MVC) paradigm, which is modified for the C++ environment. The modified paradigm is called MVC++. In this approach the design of interactive applications starts by constructing an object model that represents the key concepts of the problem domain. This object model does not contain any user interface elements. According to the MVC++ approach, the object model is called the model part of the application. Only after the model part has been created, is the user interface designed. A collection of user interface classes is called the view. The classes that connect the model and the view form the controller, which is designed to communicate with both the model and the view. The approach presented in this paper provides a number of benefits. Advantages of the original MVC approach are obtained in a standard C++ environment, the structure of applications becomes clear and stable, and reusability as well as readability of the classes increases. Reusability is achieved by employing a mechanism called ‘abstract partners’. The approach presented in this paper is being applied in the development of a large network management system with over one million lines of C++ code running in the XII environment.     

OPT++ : an object-oriented implementation for extensible database query optimization

In this paper we describe the design and implementation of OPT++, a tool for extensible database query optimization that uses an object-oriented design to simplify the task of implementing, extending, and modifying an optimizer. Building an optimizer using OPT++ makes it easy to extend the query algebra (to add new query algebra operators and physical implementation algorithms to the system), easy to change the search space, and also to change the search strategy. Furthermore, OPT++ comes equipped with a number of search strategies that are available for use by an optimizer-implementor. OPT++ considerably simplifies both, the task of implementing an optimizer for a new database system, and the task of evaluating alternative optimization techniques and strategies to decide what techniques are best suited for that database system. We present the results of a series of performance studies. These results validate our design and show that, in spite of its flexibility, OPT++ can be used to build efficient optimizers. Received October 1996 / Accepted January 1998     

Statistical Learning by Imitation of Competing Constraints in Joint Space and Task Space

We present a probabilistic architecture for solving generically the problem of extracting the task constraints through a programming by demonstration framework and for generalizing the acquired knowledge to various situations. In previous work, we proposed an approach based on Gaussian mixture regression to find a controller for the robot reproducing the statistical characteristics of a movement in joint space and in task space through Lagrange optimization. In this paper, we develop an alternative procedure to handle simultaneously constraints in joint space and in task space by combining directly the probabilistic representation of the task constraints with a solution to Jacobian-based inverse kinematics. The method is validated in manipulation tasks with two 5-d.o.f. Katana robotic arms displacing a set of objects.     

Structures of visual servos

The paper classifies visual servos and using this classification derives their possible structures. It also analyzes the influence of robot–model calibration and robot–camera calibration on the derived control structures. The systematic derivation of possible structures of visual servos enabled the creation of software patterns within the MRROC++ (Zieliński et al., 2007) [29] robot programming framework facilitating their implementation. Those considerations are preceded by a brief introduction defining the principal concepts used in the paper. The paper is concluded by presenting the use of the derived structures in the experiments with grasping static and tracking moving objects. The paper highlights the advantages and drawbacks of the presented structures.     

POW! – The Programmers Open Workbench

This paper is about POW! the Programmers Open Workbench, a flexible and extensible programming environment for personal computers. POW! has been developed for programming lectures at high schools and universities and has been used successfully for the past few years. POW! is based on a modular architecture and can be adapted to many different programming languages and compilers. Until now there are compiler modules for the languages Oberon-2, C, C++ and Java. This text covers the structure and implementation of POW! It also compares POW! with other programming environments for personal computers.     

Using abstract models for the generation of test data with a complex structure

An approach to the automatic generation of test data having a complex structure (such as XML documents, programs in various programming languages, and the like) is presented. It is based on abstract models that represent various views of the structure of the desired data. The approach enables one to generate small sets of test data for testing the functionality of the target system. The use of abstract models makes configuration of the generation procedure easy and clear; it also facilitates the maintenance and reuse of existing configurations of the test data generator. The approach was implemented in the test data generator called Pinery, which was successfully used in a number of projects including testing commercial C/C++ compilers.     

一种梯形图编程系统的研究与实现方法

详细阐述了一种梯形图编程系统的数据结构与实现方法.该系统选用Visual C 作为开发语言,实现了梯形图语言向指令表语言的转换、显示、编辑、以及语法、逻辑错误检测与处理以及程序传输等功能.该梯形图编程系统可用于多种现场测控设备如PLC、RTU等.     

Robot language for manipulation systems programming,teaching, and verification of control algorithms

The paper describes language UMS for manipulation task programming and manipulation systems teaching. Basic features of the language are outlined and the approach to the trajectory synthesis with motion statements is described. The structure of the language is briefly explained as well as the instruction set. The language is compared with some other industrial robot languages.     

Combining preprocessor slicing with C/C++ language slicing

Of the very few practical implementations of program slicing algorithms, the majority deal with C/C++ programs. Yet, preprocessor-related issues have been marginally addressed by these slicers, despite the fact that ignoring (or only partially handling) these constructs may lead to serious inaccuracies in the slicing results and hence in the program analysis task being performed. Recently, an accurate slicing method for preprocessor-related constructs has been proposed, which-when combined with existing C/C++ language slicers-can provide more complete slices and hence a more successful analysis of programs written in one of these languages. In this paper, we present our approach which combines the two slicing methods and, via practical experiments, describe its benefits in terms of the completeness of the resulting slices.     

A Systematic Approach to Metamodeling Environments and Model Transformation Systems in VMTS

Highly configurable metamodeling environments and graph transformation techniques have been applied successfully in software system modeling and other areas. In this paper a uniform treatment of these two methods is illustrated by a tool called Visual Modeling and Transformation System. The concepts of an n-layer metamodeling environment is outlined with the related topological and attribute issues. Built on metamodeling techniques two alternatives for model transformation are elaborated, namely, the traversal and the graph-rewriting approaches. In our implementation all of the aforementioned mechanisms use metamodel as a common formalism, which can be considered as a uniform basis for storing, creating and transforming visual languages. The feasibility of the approach is illustrated by a transformation which generates C/C++ code from UML statecharts.     

The UniSet approach for the programming of flexible manufacturing cells

Flexible manufacturing cells (FMC) may be considered the most significant development in small-batch manufacturing. Setting-up and operating costs of FMC prove to be the most major hindrance to their large-scale implementation and use, particularly by small and medium size industries. Incompatibilities between the different components constituting the cells and the lack of a unified language/approach to programming and coordinating them are cited as the cause of the complexity of setting up and subsequently operating the cells. In order to eliminate these difficulties, a new philosophy for setting-up, programming and control of FMC has been developed. This paper reports the effort to develop this new unified manufacturing instruction set and its environment, called here “UniSet”, its philosophy and some of the components of the UniSet environment. UniSet has been developed as a non-exclusive unified manufacturing instruction set, based on comparisons of the prevailing machine tool and programming primitives. UniSet allows programmers to deal with only one instruction set, if they so desire, in a single coherent environment, rather than numerous machine programming languages. The software system is coded in an object-oriented programming (OOP) language, Smalltalk, and derives its paradigm from the OO philosophy. Test results are also included to demonstrate the applicability of the approach employed.     

Ceiling Beam Screw Removal Using a Robotic Manipulator

The decreasing availability of skilled labor has led to the desire for supplementing workers with robot assistants that can reduce their workload. The Japanese government has undertaken a project to reduce the time and effort required to demolish a building interior by developing robot assistants that can perform the more physically demanding tasks. These include a robot to assist in removing ceiling-mounted equipment and a robot that uses a novel water-jet approach to cut down suspended ceiling tiles. Within this project, a missing component is the removal of the screws from the suspended ceiling beams. This is a physically demanding task, but also repetitive and so suitable for automation. This paper describes a robot to perform the task of removing the screws from the suspended ceiling beams. The robot uses a specially designed tool mounted at the end of an arm. This tool removes screws by turning them between two rollers. The tool is moved down the beam in a single motion, allowing it to remove many screws fast with little operator interaction. RT-Middleware is used as the implementation architecture.     

Programming language concepts for multiprocessors

It is currently possible to build multiprocessor systems which will support the tightly coupled activity of hundreds to thousands of different instruction streams, or processes. This can be done by coupling many monoprocessors, or a smaller number of pipelined multiprocessors, through a high concurrency switching network. The switching network may couple processors to memory modules, resulting in a shared memory multiprocessor system, or it may couple processor/memory pairs, resulting in a distributed memory system.

The need to direct the activity of very many processes simultaneously places qualitatively different demands on a programming language than the direction of a single process. In spite of the different requirements, most languages for multiprocessors have been simple extensions of conventional, single stream programming languages. The extensions are often implemented by way of subroutine calls and have little impact on the basic structure of the language. This paper attempts to examine the underlying conceptual structure of parallel languages for large-scale multiprocessors on the basis of an existing language for shared memory multiprocessors, known as the Force, and to extend the concepts in this language to distributed memory systems.     

Pipeline pattern in an object‐oriented,task‐parallel environment

Task parallelism is an approach to parallel programming that has recently gained traction because of its compatibility with the predominant object‐oriented languages and its low overhead compared to threading approaches. Parallel Task is an Open Source task‐parallel compiler and runtime system for object‐oriented languages, in particular Java. It is very flexible and expressive, demonstrated by the fact that it can be directly employed to implement most parallel computing patterns. The only notable exception has been the pipeline pattern where many data items are streamed through a number of processing stages. This is not surprising, as task parallelism is generally not compatible with the pipeline pattern. In this paper, we investigate how the pipeline pattern can be elegantly and efficiently implemented in a task‐parallel environment. To do so, we extend Parallel Task with the concept of implicit futures to allow creating pipelines in an intuitive and object‐oriented manner. Our experimental evaluation uses the extended Parallel Task to implement pipelines of different lengths and characteristics and compares with manual implementations. The evaluation demonstrates very good performance and scalability of the proposed task‐parallel pipeline approach. Copyright © 2014 John Wiley & Sons, Ltd.     

Domain-specific languages: from design to implementationapplication to video device drivers generation

Domain-specific languages (DSL) have many potential advantages in terms of software engineering, ranging from increased productivity to the application of formal methods. Although they have been used in practice for decades, there has been little study of methodology or implementation tools for the DSL approach. We present our DSL approach and its application to a realistic domain: the generation of video display device drivers. The article focuses on the validation of our proposed framework for domain-specific languages, from design to implementation. The framework leads to a flexible design and structure, and provides automatic generation of efficient implementations of DSL programs. Additionally, we describe an example of a complete DSL for video display adaptors and the benefits of the DSL approach for this application. This demonstrates some of the generally claimed benefits of using DSLs: increased productivity, higher-level abstraction, and easier verification. This DSL has been fully implemented with our approach and is available. Compose project URL: http://www.irisa.fr/compose/gal     

Three-Dimensional Path Planning of a Climbing Robot Using Mixed Integer Linear Programming

The City-Climber robot is a novel wall-climbing robot developed at The City College of New York that has the capability to move on floors, climb walls, walk on ceilings and transit between them. In this paper, we first develop the dynamic model of the City-Climber robot when it travel on different surfaces, i.e., floors, walls and ceilings, respectively. Then, we present a path planning method for the City-Climber robot using mixed integer linear programming (MILP) in three-dimensional (3-D) building environments that consist of objects with primitive geometrical shapes. MILP provides an optimization framework that can directly incorporate dynamic constraints with logical constraints such as obstacle avoidance and waypoint selection. In order to use MILP to solve the obstacle avoidance problem, we simplify and decouple the robot dynamic model into a linear system by introducing a restricting admissible controller. The decoupled model and obstacle can be rewritten as a linear program with mixed-integer linear constraints that account for the collision avoidance. A key benefit of this approach is that the path optimization can be readily solved using the AMPL and CPLEX optimization software with a MATLAB interface. Simulation results show that the framework of MILP is well suited for path planning and obstacle avoidance problems for the wall-climbing robot in 3-D environments.     

A C++ Simulator Generator from Graphical Specifications

Many languages for computer systems simulation (like GPSS and CSim) use a stochastic model of systems with the provision of adding procedural code for those aspects of the system that cannot be captured easily by a stochastic model. However, they do not support the hierachical simulation of complex systems well. Complex computer systems may have to be simulated at various levels of abstraction in the interests of tractability: the flexibility of being able to freely move between the different levels of abstraction is very desirable. For example, in the area of computer architecture, one might have analytical models, detailed simulation models and trace-driven models. In addition, these languages do not have user-friendly interfaces for specification of the simulated system. In this paper, we discuss the design and implementation of a simulation package for hierachical simulation of non-real-time computer systems: a Simulator Generator from a Graphical System Specification (SIGGSYS}). A new language for system specification has been designed. In addition, the package has the following components: • A graphical user interface to aid specification of the system to be simulated. • A rear end that generates C++ code that implements a simulator for the specified system. • A complete object library along with the header files that implement a functionally complete set of C++ base classes which can be built upon. C++ has been chosen as the intermediate language so that the modeller can use its support for object oriented programming. © 1997 John Wiley & Sons, Ltd.     

New perspectives in ontological analysis: Guidelines and rules for incorporating modelling languages into UEML

Ontological analysis of modelling languages has been mainly used for evaluating quality of modelling language w.r.t. one specific upper ontology. Generally speaking this evaluation has been done by identifying the coverage of the modelling language constructs w.r.t. the ontology and vice-versa. However, a quite limited support has been developed for performing the ontological analysis task. Specifically, various ontologies used for ontological analysis are not associated to a machine readable format; the coverage of modelling language constructs is mostly provided by informal tables mapping one construct on to one ontological concept; the way in which this coverage task is undertaken is poorly specified (resulting in distinct results for distinct experts involved), and finally, preventing any ontology enrichment for dealing with some specialised language constructs. This limited support also prevents application of ontological analysis outcomes to problems and domains dealing with interoperability, integration and integrated usage of enterprise and IS models, which is today one of the key aspects for making interoperable, maintainable and evolvable inter and intra enterprise software systems. The paper provides an overview of the Unified Enterprise Modelling Language (UEML) approach, which introduces advanced support to ontological analysis of modelling languages. The paper is specifically focused on the task of ontological analysis of modelling languages (named incorporation of modelling languages) by introducing and explaining several guidelines and rules for driving the task: therefore, not all the aspects of the UEML approach will be discussed through the paper. The guidelines and rules are illustrated by incorporation of three selected modelling constructs from IDEF3, a well known language for specifying enterprise processes.