Automatic Code Generation Research Articles

High-Level Design of Wireless Sensor Networks for Performance Optimization Under Security Hazards

The increasing complexity of current wireless sensor networks requires efficient methodologies to fulfill the strict constraints typically imposed in terms of power consumption and system performance. Furthermore, security issues are also becoming key features due to their impact on system behavior. As a consequence, new design frameworks are required to enable developers to model and address security risks from the very beginning of the WSN design process, while optimizing system performance. For this purpose, this article presents a design framework for modeling and simulating WSNs under external attacks. In this framework, the WSN is specified by using UML/MARTE models, from which automatic code generation enables fast, host-compiled simulation. The resulting information enables early detection of weaknesses in WSN designs and simplifies further exploration of design solutions. Minor modifications in the UML models are sufficient to automatically simulate and evaluate each design alternative in an iterative way. As a result, designers can develop more secure and optimized WSN systems with reduced design times and effort.

Automation of tool path generation in multi-process micromachine tool for micromachining of prismatic and rotational parts

ABSTRACTComputer numerical control (CNC) code generation is an inimitable activity of a Computer-aided manufacturing (CAM) system. Tool path formulation is considered as a machine-dependent activity, and expertise is essential to make attuned for a specific micromachine tool. This paper describes research for retrofitting of a multi-process micromachine tool for automatic CNC code generation for 2.5D micromachining. Micro turning, micro drilling and micro end milling processes are all considered. The proposed system comprises of three main elements: (i) part feature extraction through an extensible mark-up language (XML) schema, (ii) manufacturing logic formulation and CNC code generation by means of mathematical logic and (iii) online integration. XML-based feature extraction ensures trouble-free integration with the decision-making system. Automation of CNC code generation eliminates the need of human expertise, avoids compatibility issues and minimises program creation time. The developed system integrated with the micromachine tool through communication interface for real-time micromachining. The proposed system is intended for 2.5D machining of miniature and micro parts with external step, hole and slot features. The developed system performance has been validated through case study implementations.

Timing analysis tools in a model-driven development environment

This paper discusses the use of timing analysis tools on software systems developed with model-driven engineering methodologies. Model-driven development is mainly based on model transformations and automatic code generation. However, a deep understanding of the internal structure and behaviour of the automatically generated code is required in order to conduct later phases of the lifecycle, including validation of non-functional requirements such as real-time properties. The paper describes the integration of a timing analysis tool with TASTE, a model-driven environment developed under the auspices of the European Space Agency. A study of the influence of using an MDE approach on timing analysis techniques, along with figures on the proportion of automated and human-written code in a representative example of a spacecraft attitude control system is included in the paper.

A computer based approach for Material, Manpower and Equipment managementin the Construction Projects

The success of any construction project will depend on efficient management of resources in a perfect manner to complete the project with a reasonable budget and time and the quality cannot be compromised. The efficient and timely procurement of material, deployment of adequate labor at correct time and mobilization of machinery lacking in time, all of them causes delay, lack of quality and finally affect the project cost. It is known factor that Project cost can be controlled by taking corrective actions on mobilization of resources at a right time. This research focuses on integration of management systems with the computer to generate the model which uses OOM data structure which decides to include automatic commodity code generation, automatic takeoff execution, intelligent purchase order generation, and components of design and schedule integration to overcome the problems of stock out. To overcome the problem in equipment management system inventory management module is suggested and the data set of equipment registration number, equipment number, description, date of purchase, manufacturer, equipment price, market value, life of equipment, production data of the equipment which includes equipment number, date, name of the job, hourly rate, insurance, depreciation cost of the equipment, taxes, storage cost, interest, oil, grease, and fuel consumption, etc. is analyzed and the decision support systems to overcome the problem arising out improper management is generated. The problem on labor is managed using scheduling, Strategic management of human resources. From the generated support systems tool, the resources are mobilized at a right time and help the project manager to finish project in time and thereby save the abnormal project cost and also provides the percentage that can be improved and also research focuses on determining the percentage of delays that are caused by lack of management of materials, manpower and machinery in different types of projects and how the percentage various from project to project.

A Robust Exact Differentiator Toolbox for Matlab®/Simulink®

This paper demonstrates the functionality and ease of use of a recently implemented robust exact differentiator block for numerical simulations performed within the Matlab/Simulink software environment. It is demonstrated that the differentiator block may be used for various applications and may be easily integrated within existing Simulink models. The underpinning discrete-time differentiation algorithm is briefly outlined and its parameters for differentiator orders up to 10 are presented. An extended version of the toolbox supports the so-called automatic code generation feature of Matlab/Simulink. This functionality allows compilable code to be produced for many available hardware platforms. Three applications are presented in the paper, two of which require the generation of executable code. The third simulation-based application presents a differentiator based edge detection algorithm for image processing purposes which directly utilises the Simulink block. The three applications employ differentiators of order 4, 3 and 2, respectively.

Automatic Code Generation and Code Reusability through Software Clone Repositories

Automatic Code Generation and Code Reusability through Software Clone Repositories

Modeling and automatic code generation for wireless sensor network applications using model-driven or business process approaches: A systematic mapping study

Abstract This systematic mapping study investigates the modeling and automatic code generation initiatives for wireless sensor network applications based on the IEEE 802.15.4 standard, trying to understand the reasons, characteristics and methods used in the approaches available in the scientific literature, identifying research gaps and potential approaches that can be better exploited, indicating new possibilities of research. The focus is on studies that follow the Model-Driven or Business Process approaches.

Hybrid automata: from verification to implementation

Hybrid automata are an important formalism for modeling dynamical systems exhibiting mixed discrete–continuous behavior such as control systems and are amenable to formal verification. However, hybrid automata lack expressiveness compared to integrated model-based design frameworks such as the MathWorks’ Simulink/Stateflow (SlSf). In this paper, we propose a technique for correct-by-construction compositional design of cyber-physical systems (CPS) by embedding hybrid automata into SlSf models. Hybrid automata are first verified using verification tools such as SpaceEx and then automatically translated to embed the hybrid automata into SlSf models such that the properties verified are transferred and maintained in the translated SlSf model. The resultant SlSf model can then be used for automatic code generation and deployment to hardware, resulting in an implementation. The approach is implemented in a software tool building on the HyST model transformation tool for hybrid systems. We show the effectiveness of our approach on a CPS case study—a closed-loop buck converter—and validate the overall correct-by-construction methodology: from formal verification to implementation in hardware controlling an actual physical plant.

A toolchain for the automatic generation of computer codes for correlated wavefunction calculations.

In this work, the automated generator environment for ORCA (ORCA-AGE) is described. It is a powerful toolchain for the automatic implementation of wavefunction-based quantum chemical methods. ORCA-AGE consists of three main modules: (1) generation of "raw" equations from a second quantized Ansatz for the wavefunction, (2) factorization and optimization of equations, and (3) generation of actual computer code. We generate code for the ORCA package, making use of the powerful functionality for wavefunction-based correlation calculations that is already present in the code. The equation generation makes use of the most elementary commutation relations and hence is extremely general. Consequently, code can be generated for single reference as well as multireference approaches and spin-independent as well as spin-dependent operators. The performance of the generated code is demonstrated through comparison with efficient hand-optimized code for some well-understood standard configuration interaction and coupled cluster methods. In general, the speed of the generated code is no more than 30% slower than the hand-optimized code, thus allowing for routine application of canonical ab initio methods to molecules with about 500-1000 basis functions. Using the toolchain, complicated methods, especially those surpassing human ability for handling complexity, can be efficiently and reliably implemented in very short times. This enables the developer to shift the attention from debugging code to the physical content of the chosen wavefunction Ansatz. Automatic code generation also has the desirable property that any improvement in the toolchain immediately applies to all generated code. © 2017 Wiley Periodicals, Inc.

Reconfigurable Constant Multiplication for FPGAs

This paper introduces a new heuristic to generate pipelined run-time reconfigurable constant multipliers for field-programmable gate arrays (FPGAs). It produces results close to the optimum. It is based on an optimal algorithm which fuses already optimized pipelined constant multipliers generated by an existing heuristic called reduced pipelined adder graph (RPAG). Switching between different single or multiple constant outputs is realized by the insertion of multiplexers. The heuristic searches for a solution that results in minimal multiplexer overhead. Using the proposed heuristic reduces the run-time of the fusion process, which raises the usability and application domain of the proposed method of run-time reconfiguration. An extensive evaluation of the proposed method confirms a 9%–26% FPGA resource reduction on average compared to previous work. For reconfigurable multiple constant multiplication, resource savings of up to 75% can be shown compared to a standard generic lookup table based multiplier. Two low level optimizations are presented, which further reduce resource consumption and are included into an automatic VHDL code generation based on the FloPoCo library.

Building Trust in a Model-Based Automatic Code Generator

If we wish to use an automatic code generator for the modelbased development of a safety-critical system, how can we gain sufficient confidence in the correctness of the tool? For a tool like a code generator, which could insert an error into an airborne system, the US Federal Aviation Administration (FAA) requires the highest level of tool qualification [2], Tool Qualification Level 1 (TQL-1), if the tool is going to be used for a Level-A subsystem (one whose failure could be catastrophic). Achieving TQL-1 for such a code generator is analogous to achieving Level A certification for an embedded software component, but the lines of code in the tool can be substantially greater. In this paper we describe approaches to manage the complexity of specification and testing required for Level-1 qualification of a tool like an automatic code generator, a tool which includes multiple phases that transform an input model into optimized generated code.

SQL-PL4OCL: an automatic code generator from OCL to SQL procedural language

In this paper, we introduce a SQL-PL code generator for OCL expressions that, in contrast to other proposals, is able to map OCL iterate and iterator expressions thanks to our use of stored procedures. We explain how the mapping presented here introduces key differences to the previous version of our mapping in order to (i) simplify its definition, (ii) improve the evaluation time of the resulting code, and (iii) consider OCL three-valued evaluation semantics. Moreover, we have implemented our mapping to target several relational database management systems, i.e., MySQL, MariaDB, PostgreSQL, and SQL server, which allows us to widen its usability and to benchmark the evaluation time of the SQL-PL code produced.

Physical object-oriented modeling in development of individualized teaching and organization of mini-research in mechanics courses

Subject of Research. The paper presents a relatively simple method to develop interactive computer models of physical systems without computer programming skills or automatic generation of the numerical computer code for the complex physical systems. Developed computer models are available over the Internet for educational purposes and can be edited by users in an unlimited number of possibilities. An applicability of computer simulations for the massive open individualized teaching and an organization of undergraduate research are also discussed. Method. The presented approach employs an original physical object-oriented modeling method, which is an extension of object-oriented programming ideas to tasks of developing simulations of the complex physical systems. In this framework, a computer model of the physical system is constructed as a set of interconnected computer objects simulating the system components: particles and fields. Interactions between the system components are described by self-adapting algorithms that are specified during the model initiation stage and are set according to either the classical or relativistic approach. The utilized technique requires neither a priori knowledge regarding an evolution of the physical system nor a formulation of differential equations describing the physical system. Main Results. Testing of the numerical implementation and an accuracy of the algorithms was performed with the use of benchmarks with the known analytical solutions. The developed method - a physical reality constructor - has provided an opportunity to assemble a series of computer models to demonstrate physical phenomena studied in the high school and university mechanic courses. More than 150 original interactive models were included into the collections of multi-level multimedia resources to support teaching of the mechanics. The physical reality constructor was successfully tested to serve as a test bed for the independent research by students on physical properties of complex mechanical systems, the analysis of which is beyond the scope of the standard physics and mathematics curriculum. The heuristic capabilities of models created by the physical reality constructor were also demonstrated. The capability to investigate dynamics of the complex systems, an a priori analysis of which is not evident or with a difficult or impossible-to-calculate evolution, was also demonstrated. Practical Relevance. The developed computer program for automated development of interactive educational simulations provides a solution to standing problems in accompanying massive open individualized learning multi-level courses in physics as well as an opportunity to develop creative forms of training in physics with elements of research.

MOSAIC – Enabling Large‐Scale Equation‐Based Flow Sheet Optimization

AbstractDedicated software exists for both process simulation and optimization. Given the advantages of simultaneous optimization schemes, engineers are frequently tasked with reimplementing their simulation models in optimization languages or environments. In this contribution, a workflow is introduced to model chemical engineering models in MathML and to have an automatic code generation for both specialized simulation and optimization tools. Two examples are given to highlight the performance of this workflow implemented in the modeling, simulation, and optimization environment MOSAIC.

Toward a rapid development of social network-based recommender systems

Actions carried out in social networks such as Facebook, Twitter, Foursquare, and the like, can greatly benefit the quality of recommendations provided by recommender systems. Usual interactions on these platforms provide valuable information on user preferences and proximity with other users. However, the use of this information by external recommender systems is still incipient and developers have little support to do it efficiently. In this paper, we introduce a model-driven development framework for recommenders systems based on social networks. The core of this framework is an abstract, social network-independent model of recommender systems, which combines domain-independent concepts of collaborative filtering with basic concepts of social networks that can be exploited for recommendation purposes. From this model, developers can specify the structure and algorithms of domain-specific recommender systems at a high abstraction level. An automatic code generation strategy supports the implementation phase. Experiments show promising results in development-time saving.

A feature-based classification of formal verification techniques for software models

Software models are the core development artifact in model-based engineering (MBE). The MBE paradigm promotes the use of software models to describe structure and behavior of the system under development and proposes the automatic generation of executable code from the models. Thus, defects in the models most likely propagate to executable code. To detect defects already at the modeling level, many approaches propose to use formal verification techniques to ensure the correctness of these models. These approaches are the subject of this survey. We review the state of the art of formal verification techniques for software models and provide a feature-based classification that allows us to categorize and compare the different approaches.

Automated Generation of BSP Automata

Bulk-Synchronous Parallel (BSP) is a bridging model between abstract execution and concrete parallel architectures that retains enough information to model performance scalability. In order to model BSP program executions, Hains adapted the theory of finite automata to the BSP paradigm by introducing BSP automata [12]. In the initial description of the theory, BSP automata had to be explicitly defined as structured sets of states and transitions. The lack of a clean and efficient algorithm for generating them from regular expressions would have prevented this theory from being used in practice. To alleviate this problem we introduce in this paper an algorithm that generates a BSP automaton recognizing a BSP language defined by a BSP regular expression. The main practical use of BSP automata developed in this paper is the parallelization of finite state automata with an explicit distribution and a performance model, that enable parallel matching of regular expressions. Secondarily, BSP regular expressions provide a convenient structure for automatic code generation of imperative BSP programs that is also developed in this paper.

The IOPT-Flow Modeling Framework Applied to Power Electronics Controllers

The input–output place-transition (IOPT)-flow modeling framework was created to support the design of mixed embedded system controllers containing both reactive and data-driven parts, combining Petri net and dataflow elements. The reactive parts, whose evolution depends on external events, are modeled using Petri nets. Data manipulation operations that process input signals and events are expressed using dataflows. The framework is composed by a Web-based tool-chain including a graphical editor, a simulator, and automatic code generation tools to produce C and VHDL controller implementations. To demonstrate the language and the related tools, an example of a closed-loop brushless dc servo motor controller is presented. A prototype using the automatic generated VHDL code was implemented on a field-programmable gate array (FPGA) board.

산업용 로봇 제어를 위한 Preempt-RT 기반 멀티코어 모션 제어기의 구현 및 성능 평가

Recently, with the ever-increasing complexity of industrial robot systems, it has been greatly attention to adopt a multi-core based motion controller with high cost-performance ratio. In this paper, we propose a software architecture that aims to utilize the computing power of multi-core processors. The key concept of our architecture is to use shared memory for the interplay between threads running on separate processor cores. And then, we have integrated our proposed architecture with an industrial standard compliant IDE for automatic code generation of motion runtime. For the performance evaluation, we constructed a test-bed consisting of a motion controller with Preempt-RT Linux based dual-core industrial PC and a 3-axis industrial robot platform. The experimental results show that the actuation time difference between axes is 10 ns in average and bounded up to 689 ns under <TEX>$1000{\mu}s$</TEX> control period, which can come up with real-time performance for industrial robot.

PyJac: Analytical Jacobian generator for chemical kinetics

Accurate simulations of combustion phenomena require the use of detailed chemical kinetics in order to capture limit phenomena such as ignition and extinction as well as predict pollutant formation. However, the chemical kinetic models for hydrocarbon fuels of practical interest typically have large numbers of species and reactions and exhibit high levels of mathematical stiffness in the governing differential equations, particularly for larger fuel molecules. In order to integrate the stiff equations governing chemical kinetics, generally reactive-flow simulations rely on implicit algorithms that require frequent Jacobian matrix evaluations. Some in situ and a posteriori computational diagnostics methods also require accurate Jacobian matrices, including computational singular perturbation and chemical explosive mode analysis. Typically, finite differences numerically approximate these, but for larger chemical kinetic models this poses significant computational demands since the number of chemical source term evaluations scales with the square of species count. Furthermore, existing analytical Jacobian tools do not optimize evaluations or support emerging SIMD processors such as GPUs. Here we introduce pyJac, a Python-based open-source program that generates analytical Jacobian matrices for use in chemical kinetics modeling and analysis. In addition to producing the necessary customized source code for evaluating reaction rates (including all modern reaction rate formulations), the chemical source terms, and the Jacobian matrix, pyJac uses an optimized evaluation order to minimize computational and memory operations. As a demonstration, we first establish the correctness of the Jacobian matrices for kinetic models of hydrogen, methane, ethylene, and isopentanol oxidation (number of species ranging 13–360) by showing agreement within 0.001% of matrices obtained via automatic differentiation. We then demonstrate the performance achievable on CPUs and GPUs using pyJac via matrix evaluation timing comparisons; the routines produced by pyJac outperformed first-order finite differences by 3–7.5 times and the existing analytical Jacobian software TChem by 1.1–2.2 times on a single-threaded basis. It is noted that TChem is not thread-safe, while pyJac is easily parallelized, and hence can greatly outperform TChem on multicore CPUs. The Jacobian matrix generator we describe here will be useful for reducing the cost of integrating chemical source terms with implicit algorithms in particular and algorithms that require an accurate Jacobian matrix in general. Furthermore, the open-source release of the program and Python-based implementation will enable wide adoption. Program summaryProgram Title: pyJacProgram Files doi:http://dx.doi.org/10.17632/mmr3z8j2m5.1Licensing provisions: MIT LicenseProgramming language: PythonExternal routines/libraries: required: NumPy; optional: Cython, Cantera, PyYAML, AdeptNature of problem: Automatic generation of source code to evaluate Jacobian matrices for chemical kinetic modelsSolution method: Chemical kinetic model interpreted from input file(s), and partial derivatives and necessary supporting functions are written to file based on a theoretical derivation.Additional comments: This paper describes pyJac v1.0.2, available at http://dx.doi.org/10.5281/zenodo.251144. Current version and support available at https://github.com/SLACKHA/pyjac/