Automatic Code Generation Tools Research Articles

A conic programming approach to the wrinkling of pneumatic membranes using convex potentials

This paper presents a novel conic programming approach for modeling the wrinkling of isotropic hyperelastic membranes subject to nonlinear loading and finite strains, employing convex potentials derived from tension field theory. The incompressible neo-Hookean strain energy is recast as a minimization problem over a set of cones, with a semidefinite constraint on the deformed surface metric. To address pneumatic membranes, a linearized volumetric potential is introduced, reestablishing convexity for follower forces, and Boyle's law is expressed as a minimization problem over the exponential cone.The primal–dual interior point method solves the total potential energy minimization problem, with convergence verified using the analytical solution of a sheared planar membrane. The proposed model, applied to examples of increasing complexity, reveals intriguing membrane behaviors rarely discussed in existing literature. The method is shown to be robust, even when handling highly wrinkled membranes, which are challenging to address using direct nonlinear equilibrium analysis or nonlinear interior point methods.Implementation using high-level automatic code generation tools (FEniCS) results in concise, extensible code. The findings point to several avenues for future research, such as exploring complex material models, mesh refinement, dynamics, and parametric design. Additionally, the linearization process implies potential applicability of the methods to nonlinear problems beyond membrane mechanics.

Code Swarm: A Code Generation Tool based on the Automatic Derivation of Transformation Rule Set

Automatic generation of software code from system design models remains an actively explored research area for the past several years. A number of tools are currently available to facilitate and automate the task of generating code from software models. To the best of our knowledge, existing software tools rely on an explicitly defined transformation rule set to perform the model-to-code transformation process. In this paper, we introduce a novel tool named Code Swarm, abbreviated as CodS, that automatically generates implementation code from system design models by utilizing a swarm-based approach. Specifically, CodS is capable of generating Java code from the class and state models of the software system by making use of the previously solved model-to-code transformation examples. Our tool enables the designers to specify behavioural actions in the input models using the Action Specification Language (ASL). We use an industrial case study of the Elevator Control System (ECS) to perform the experimental validation of our tool. Our results indicate that the code generated by CodS is correct and consistent with the input design models. CodS performs the process of automatic code generation without taking the explicit transformation rule set or languages metamodels’ information as input, which distinguishes it from all the existing automatic code generation tools.

The Metric for Automatic Code Generation Based on Dynamic Abstract Syntax Tree

In order to improve the efficiency and quality of software development, automatic code generation technology is the current focus. The quality of the code generated by the automatic code generation technology is also an important issue. However, existing metrics for code automatic generation ignore that the programming process is a continuous dynamic changeable process. So the metric is a dynamic process. This article proposes a metric method based on dynamic abstract syntax tree (DAST). More specifically, the method first builds a DAST through the interaction in behavior information between the automatic code generation tool and programmer. Then the measurement contents are extracted on the DAST. Finally, the metric is completed with contents extracted. The experiment results show that the method can effectively realize the metrics of automatic code generation. Compared with the MAST method, the method in this article can improve the convergence speed by 80% when training the model, and can shorten the time-consuming by an average of 46% when doing the metric prediction.

A thermalized electrokinetics model including stochastic reactions suitable for multiscale simulations of reaction–advection–diffusion systems

We introduce a scheme to simulate the spatial and temporal evolution of the densities of charged species, taking into account diffusion, thermal fluctuations, coupling to a carrier fluid, and chemical reactions. To this end, the diffusive fluxes in the electrokinetic model by Capuani et al. (2004) are supplemented with thermal fluctuations. Chemical reactions are included via an additional source term in the mass balance equation. The diffusion–reaction model is then coupled to a solver for fluctuating hydrodynamics based on the lattice Boltzmann method. This combination is particularly useful for soft matter simulations, due to the ability to couple particles to the lattice-Boltzmann fluid. These could, e.g., be charged colloids or polymers, which then interact with an ion distribution. We describe one implementations based on the automatic code generation tools pystencils and lbmpy, and another one that is contained in the molecular dynamics package ESPResSo and that allows for an easy coupling of particles to the density fields. We validate our implementations by comparing to several known analytic results. Our method can be applied to coarse-grained catalysis problems as well as to many other multi-scale problems that require the coupling of explicit-particle simulations to flow fields, diffusion, and reaction problems in arbitrary geometries.

Performance Estimation of High-Level Dataflow Program on Heterogeneous Platforms by Dynamic Network Execution

The performance of programs executed on heterogeneous parallel platforms largely depends on the design choices regarding how to partition the processing on the various different processing units. In other words, it depends on the assumptions and parameters that define the partitioning, mapping, scheduling, and allocation of data exchanges among the various processing elements of the platform executing the program. The advantage of programs written in languages using the dataflow model of computation (MoC) is that executing the program with different configurations and parameter settings does not require rewriting the application software for each configuration setting, but only requires generating a new synthesis of the execution code corresponding to different parameters. The synthesis stage of dataflow programs is usually supported by automatic code generation tools. Another competitive advantage of dataflow software methodologies is that they are well-suited to support designs on heterogeneous parallel systems as they are inherently free of memory access contention issues and naturally expose the available intrinsic parallelism. So as to fully exploit these advantages and to be able to efficiently search the configuration space to find the design points that better satisfy the desired design constraints, it is necessary to develop tools and associated methodologies capable of evaluating the performance of different configurations and to drive the search for good design configurations, according to the desired performance criteria. The number of possible design assumptions and associated parameter settings is usually so large (i.e., the dimensions and size of the design space) that intuition as well as trial and error are clearly unfeasible, inefficient approaches. This paper describes a method for the clock-accurate profiling of software applications developed using the dataflow programming paradigm such as the formal RVL-CAL language. The profiling can be applied when the application program has been compiled and executed on GPU/CPU heterogeneous hardware platforms utilizing two main methodologies, denoted as static and dynamic. This paper also describes how a method for the qualitative evaluation of the performance of such programs as a function of the supplied configuration parameters can be successfully applied to heterogeneous platforms. The technique was illustrated using two different application software examples and several design points.

Extension of the Modeling Tool Suite for Development of Embedded Systems for the Space Domain

As code complexity continues to increase, software development methods must support the handling of this complexity and reduce development failures. Model-based systems engineering (MBSE) is a modeling-centered development method that provides support to maintain consistency of different phases of the life cycle. Automatic code generation tools were created to reuse software solutions and design patterns and reduce development errors in the software development process, based on automatic model transformations and code generators. However, the use of these tools requires their adaptation to specific platforms and domains since tools only support certain functionalities. What determines how to approach the design of the system are the functionalities provided by the tools available rather than the user needs. In this paper, we propose a way to extend the elements supported by modelling tool suites for real-time embedded systems for the space domain. This enables developers to have greater flexibility by allowing them to modify their tool suite to fit their needs.

Integrating complex event processing and machine learning: An intelligent architecture for detecting IoT security attacks

The Internet of Things (IoT) is growing globally at a fast pace: people now find themselves surrounded by a variety of IoT devices such as smartphones and wearables in their everyday lives. Additionally, smart environments, such as smart healthcare systems, smart industries and smart cities, benefit from sensors and actuators interconnected through the IoT. However, the increase in IoT devices has brought with it the challenge of promptly detecting and combating the cybersecurity attacks and threats that target them, including malware, privacy breaches and denial of service attacks, among others. To tackle this challenge, this paper proposes an intelligent architecture that integrates Complex Event Processing (CEP) technology and the Machine Learning (ML) paradigm in order to detect different types of IoT security attacks in real time. In particular, such an architecture is capable of easily managing event patterns whose conditions depend on values obtained by ML algorithms. Additionally, a model-driven graphical tool for security attack pattern definition and automatic code generation is provided, hiding all the complexity derived from implementation details from domain experts. The proposed architecture has been applied in the case of a healthcare IoT network to validate its ability to detect attacks made by malicious devices. The results obtained demonstrate that this architecture satisfactorily fulfils its objectives.

Automatic Code Generation Tool for Nonlinear Model Predictive Control with Jupyter

We present an automatic code generation tool, AutoGenU for Jupyter, for nonlinear model predictive control (NMPC) with a user-friendly and interactive interface utilizing JupyterLab and Jupyter Notebook. We utilize a symbolic computation package SymPy for automatic C++ code generation. We also developed numerical solvers of NMPC using the continuation/GMRES (C/GMRES) method and multiple-shooting-based C/GMRES method in C++. AutoGenU for Jupyter provides the simulation environment of NMPC with these solvers and visualization of the simulation results. We give an example of code generation and numerical simulation of a swing-up control of a cart pole using AutoGenU for Jupyter.

The Metric for Automatic Code Generation

Abstract At present, there are a lot of researches on the metric about static source code. However, there are few studies about automatic code generation. Based on the quality and efficiency of automatic code generation, this paper proposes the metric model including six metric characteristics. Then, three automatic code generation tools are used to measure the experimental source code. Finally, the experimental results showed that the metric of automatic code generation is effective.

Designing and Interpreting a Mathematical Programming Language

The syntax of the programming languages has a significant impact on the definition and validation of mathematical calculations. In particular, the management of code identification and validation processes can be made easier and faster, depending on the parametric behavior of the functions. In this article, a programming language that supports the use of mathematical function structures is designed and an interpreter, which can evaluate the source code written in this language, is developed. The language syntax is represented by an LL (k) grammar defined in the BNF notation. The interpreter consists of several basic components such as parser, semantic controller and code evaluator, each of which makes a different kind of code interpretation. The LL (k) parser component used for the syntactic analysis of the language is generated via an automatic code generation tool called JavaCC. The other components work on the abstract syntactic tree that this parser generates. To illustrate the use of the language with code samples, several mathematical algorithms that include calculations on different sequences of numbers, are programmed and interpreted.

Template-based AADL automatic code generation

Embedded real-time systems employ a variety of operating system platforms. Consequently, for automatic code generation, considerable redevelopment is needed when the platform changes. This results in major challenges with respect to the automatic code generation process of the architecture analysis and design language (AADL). In this paper, we propose a method of template-based automatic code generation to address this issue. Templates are used as carriers of automatic code generation rules from AADL to the object platform. These templates can be easily modified for different platforms. Automatic code generation for different platforms can be accomplished by formulating the corresponding generation rules and transformation templates. We design a set of code generation templates from AADL to the object platform and develop an automatic code generation tool. Finally, we take a typical Data Processing Unit (DPU) system as a case study to test the tool. It is demonstrated that the auto-generated codes can be compiled and executed successfully on the object platform.

Simple and extensible plate and shell finite element models through automatic code generation tools

A large number of advanced finite element shell formulations have been developed, but their adoption is hindered by complexities of transforming mathematical formulations into computer code. Furthermore, it is often not straightforward to adapt existing implementations to emerging frontier problems in thin structural mechanics including nonlinear material behaviour, complex microstructures, multi-physical couplings, or active materials. We show that by using a high-level mathematical modelling strategy and automatic code generation tools, a wide range of advanced plate and shell finite element models can be generated easily and efficiently, including: the linear and non-linear geometrically exact Naghdi shell models, the Marguerre-von Kármán shallow shell model, and the Reissner-Mindlin plate model. To solve shear and membrane-locking issues, we use: a novel re-interpretation of the Mixed Interpolation of Tensorial Component (MITC) procedure as a mixed-hybridisable finite element method, and a high polynomial order Partial Selective Reduced Integration (PSRI) method. The effectiveness of these approaches and the ease of writing solvers is illustrated through a large set of verification tests and demo codes, collected in an open-source library, FEniCS-Shells, that extends the FEniCS Project finite element problem solving environment.

Proposal for a new Ada profile for small microcontrollers

This paper presents a proposal for a new Ada profile targeted to microcontrollers with tight memory constraints. The profile has the same restrictions that the Ravenscar profile but includes a new scheduling policy based on the "one-shot task" model that allows stack sharing techniques to be applied to Ada tasks. A preliminary implementation based on a small kernel, a modified run-time system and an automatic code generation tool has been developed. The initial tests bring promising results, showing the profile is functionally correct and has a small memory footprint.

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.

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.

An analysis of tools for automatic software development and automatic code generation

Software development is an important area in software engineering, which is why a wide range of techniques, methods, and approaches has emerged to facilitate software development automation. This paper presents an analysis and evaluation of tools for automated software development and automatic code generation in order to determine whether they meet a set of quality metrics. Diverse quality metrics were considered such as effectiveness, productivity, safety, and satisfaction in order to carry out a qualitative and quantitative evaluation. The tools evaluated are CASE tools, frameworks, and Integrated Development Environments (IDEs). The evaluation was conducted to measure not only the tools’ ability to be employed, but also their support for automated software development and automatic source code generation. The aim of this work is to provide a methodology and a brief review of the most important works to identify the main features of these works and present a comparative evaluation in qualitative and quantitative terms of quality metrics. This would provide software developers with the information they need to decide the tools that can be useful for them.

Real-time nonlinear MPC and MHE for a large-scale mechatronic application

Progress in optimization algorithms and in computational hardware made deployment of Nonlinear Model Predictive Control (NMPC) and Moving Horizon Estimation (MHE) possible to mechatronic applications. This paper aims to assess the computational performance of NMPC and MHE for rotational start-up of Airborne Wind Energy systems. The capabilities offered by an automatic code generation tool are experimentally verified on a real physical system, using a model comprising 27 states and 4 inputs at a sampling frequency of 25Hz. The results show the feedback times less than 5ms for the NMPC with more than 1500 variables.

AUTOMATIC PARALLEL CODE GENERATION FOR NUFFT DATA TRANSLATION ON MULTICORES

The nonuniform FFT (NuFFT) is widely used in many applications. Focusing on the most time-consuming part of the NuFFT computation, the data translation step, in this paper, we develop an automatic parallel code generation tool for data translation targeting emerging multicores. The key components of this tool are two scalable parallelization strategies, namely, the source-driven parallelization and the target-driven parallelization. Both these strategies employ equally sized geometric tiling and binning to improve data locality while trying to balance workloads across the cores through dynamic task allocation. They differ in the partitioning and scheduling schemes used to guarantee mutual exclusion in data updates. This tool also consists of a code generator and a code optimizer for the data translation. We evaluated our tool on a commercial multicore machine for both 2D and 3D inputs under different sample distributions with large data set sizes. The results indicate that both parallelization strategies have good scalability as the number of cores and the number of dimensions of data space increase. In particular, the target-driven parallelization outperforms the other when samples are nonuniformly distributed. The experiments also show that our code optimizations can bring about 32%–43% performance improvement to the data translation step of NuFFT.

The Formal Design Models of Digraph Architectures and Behaviors

Graphs are one of the most fundamental and widely used non-linear hierarchical structures of linked nodes. Problems in sciences and engineering can be formulated and solved by the graph model. This paper develops a comprehensive design pattern of formal digraphs using the Doubly-Linked List (DLL) architecture. The most complicated form of graphs known as the weighted digraph is selected as a general graph model, based on it simple graphs such as nondirected and/or nonweighted ones can be easily derived and tailored. A rigorous denotational mathematics, Real-Time Process Algebra (RTPA), is adopted, which allows both architectural and behavioral models of digraphs to be rigorously designed and implemented in a top-down approach. The architectural models of digraphs are created using RTPA architectural modeling methodologies known as the Unified Data Models (UDMs). The physical model of digraphs is implemented using nodes of DLL dynamically created in the memory. The behavioral models of digraphs are specified and refined by a set of 18 Unified Process Models (UPMs) in three categories namely the management operations, traversal operations, and node manipulation operations. This work has been applied in a number of real-time and nonreal-time system designs and specifications such as a Real-Time Operating System (RTOS+), graph-based and tree-based applications, and the ADT library for an RTPA-based automatic code generation tool.

Automated construction of the user interface for a CERIF‐compliant research management system

PurposeThis paper aims to examine the goal, which is to construct a user interface for CERIF‐compatible research management systems in an automated way. The system has to support all data items defined by the CERIF data model. The result of the automated construction is a functioning software system that can be customised according to the specific needs by manual changes in the program code.Design/methodology/approachThe Model‐Driven Architecture (MDA) approach to software engineering is based on the idea of automated construction of software applications based on the model of a system. System modelling usually utilises the Unified Modelling Language (UML). A specific UML profile (extension) used for describing user interface‐related aspects of the system model is defined. It is used to define the behaviour of the user interface in the model itself. By relying on the concept of a standard generic screen form implementing common data management operations and tools for automatic code generation it is possible to obtain a fully functional software application that is completely defined by the system model.FindingsA proposal of an automated user interface construction method for CERIF‐compatible research management systems is defined. The proposed application enables the management of all CERIF‐specified data items and facilitates the customisation of the model according to the specific needs. The customisation process is automated by using the tools for user interface code generation based on human‐computer interaction (HCI) standard defining the layout and behaviour of generic screen forms. The amount of automatically generated application functionality justifies the use of the model‐driven approach to software development.Practical implicationsUsing the model of a system it is possible to efficiently produce a functional software application that can further be customised according to the needs of specific institutions and users. The customisation process itself is made efficient since it is iteratively performed using the same cycles of modelling and software generation. The proposed method for automated user interface construction is used for implementing the web application for research management at the University of Novi Sad.Originality/valueA proposal for efficient software system development and its customisation is given. This way a software application is obtained that can be quickly adapted to new requirements and used in different research management systems based on a CERIF‐compatible data model.