Jing‐Quan Wang, Andrew Negrut, Harry Zhang et al. · ArXiv.org · 2025
This contribution is concerned with the following issue: can pretrained large language models (LLMs) be refined and customized to the point where they become virtual assistants helping experts with the effective use of a simulation tool? In this case study, the ``simulation tool'' considered is PyChrono, an open source multi-physics dynamics engine for multibody systems. We present a framework for refining and customizing both open- and closed-source LLMs to harness the power of AI in generating scripts that perform PyChrono virtual experiments. We refine and customize several classes of LLMs through a process that leads to a quantifiable improvement in the quality of the generated PyChrono simulation scripts. These scripts can range from simple single-pendulum simulations to complex virtual experiments involving full vehicles on deformable terrain. While the generated scripts are rarely perfect, they often serve as strong starting points for the user to modify and improve on. Additionally, the LLM can answer specific API questions about the simulator, or recommend modeling approaches. The framework discussed is general and can be applied to lower the entry barrier for simulation tools associated with other application domains.
Cited by 0Open access
C.D. Chamis, S.A. Ameduri, Wyatt S. Newman · 2002
This paper describes the design of a tool for rapid analysis and implementation of flexible material handling systems. The work incorporates a commercial discrete-event and 3D animation simulation system and extends its functionality with respect to material handling systems. Logical clusters of commercial, modular conveyor components are defined and installed as additions to the simulator's component libraries. These logical groupings, plus the material-flow logic specified by the user in a given simulation analysis, are used to enable automatic generation of control code for the corresponding physical implementation of the simulated system. Key elements in accomplishing this connection are the definition of component logical groupings and a novel, reactive-agent based software organization of the real-time material-handling control code.
Cited by 1
Antônio Wendell De Oliveira Rodrigues, Frédéric Guyomarc'h, Jean‐Luc Dekeyser et al. · arXiv (Cornell University) · 2011
The electrical and electronic engineering has used parallel programming to solve its large scale complex problems for performance reasons. However, as parallel programming requires a non-trivial distribution of tasks and data, developers find it hard to implement their applications effectively. Thus, in order to reduce design complexity, we propose an approach to generate code for hybrid architectures (e.g. CPU + GPU) using OpenCL, an open standard for parallel programming of heterogeneous systems. This approach is based on Model Driven Engineering (MDE) and the MARTE profile, standard proposed by Object Management Group (OMG). The aim is to provide resources to non-specialists in parallel programming to implement their applications. Moreover, thanks to model reuse capacity, we can add/change functionalities or the target architecture. Consequently, this approach helps industries to achieve their time-to-market constraints and confirms by experimental tests, performance improvements using multi-GPU environments.
Cited by 0Open access
Stefano Olivieri, Mohammad Mozumdar, Luciano Lavagno et al. · PORTO Publications Open Repository TOrino (Politecnico di Torino) · 2009
Cited by 1
N. "Nishino, T. Hirooka, T." Mio · National Institute for Fusion Science Repository (National Institute for Fusion Science)
Cited by 0
Anderson Carvalho, Felipe Alves Pereira, Marcelo Götz et al. · Anais do 14º Simpósio Brasileiro de Automação Inteligente · 2019
In manufacturing systems, a class of Discrete Event Systems (DES), plant behavior can be modeled through automata which serve as the basis for synthesizing controllers using Supervisory Control Theory (SCT). The present paper proposes the usage of Matlab Simulink Stateflow for modeling automata and for automated code generation. The usage of Matlab Simulink is encouraged by its widespread acceptance in industry providing, also, an intrinsic possibility of simulation and flexible automated code generation capability. The feasibility of the proposal is shown by preparing a testbed based on an embedded system target used to set up a hardware-in-the-loop simulation architecture.
Cited by 0Open access
Stijn Buitink · VUBIR (Vrije Universiteit Brussel) · 2019
Cited by 0
CELIA, MARCO EMANUELE · Electronic Theses and Dissertations Repository (University of Pisa) · 2017
The increasing level of complexity of modern embedded systems concurs to enhance the gap between the textual representation of High-Level System Requirements and the testing units in charge of their verification. Such gap is worsened by the possible presence of errors and omissions in the natural language requirement and causes engineers to inject into the verification units features derived from their personal interpretation. This work has the goal to provide a framework consisting of a requirements (loose) syntax, a requirements editor, a parser, and an automatic synthesis tool, which helps engineers in writing high-level requirements in a structured natural language with a contract-based paradigm, thus reducing, as much as possible, inconsistency and common errors, and directly generating verification monitors for a target platform. To restrict the domain and the framework complexity and make the problem affordable, the first version of the tool is restricted to the controls domain and assumes the use of Simulink as a modeling and simulation tool. To ease the generation process, a control verification Simulink library has been implemented.
Cited by 0Open access
Johannes Sebastian Mueller-Roemer · Eurographics · 2019
Cited by 0Open access
Antônio Wendell De Oliveira Rodrigues, Frédéric Guyomarc'h, Jean‐Luc Dekeyser et al. · IEEE Transactions on Magnetics · 2012
The electrical and electronic engineerings have used parallel programming to solve their large scale complex problems for performance reasons. However, as parallel programming requires a non-trivial distribution of tasks and data, developers find it hard to implement their applications effectively. Thus, in order to reduce design complexity, we propose an approach to generate code for hybrid architectures (e.g., CPU <formula formulatype="inline" xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink"><tex Notation="TeX">$+$</tex> </formula> GPU) using OpenCL, an open standard for parallel programming of heterogeneous systems. This approach is based on Model Driven Engineering (MDE) and the MARTE profile, standard proposed by Object Management Group (OMG). The aim is to provide resources to non-specialists in parallel programming to implement their applications. Moreover, thanks to model reuse ability, we can add/change functionalities and the target architecture. Consequently, this approach helps industries to achieve their time-to-market constraints which are confirmed here by experimental tests. Besides the software development at high-level abstractions, this approach aims to improve performance by using multi-GPU environments. A case study based on the Conjugate Gradient method gives clarity to our methodology.
Cited by 10Open access
Cristina Vicente, Ana Toledo, Pedro Sánchez-palma · 2016
Abstract. Nowadays, the market-place offers quite powerful and low cost re-configurable hardware devices and a wide range of software tools which find application in the image processing field. However, most of the image process-ing application designs and their latter deployment on specific hardware de-vices is still carried out quite costly by hand. This paper presents a new ap-proach to image processing application development, which tackles the historic question of how filling the gap existing between rapid throwaway software de-signs and final software/hardware implementations. A new graphical compo-nent-based tool has been implemented which allows to comprehensively de-velop this kind of applications, from functional and architectural prototyping stages to software/hardware co-simulation and final code generation. Building this tool has been possible thanks to the synergy that arises from the integration of several of the pre-existent software and hardware image processing libraries and tools.
Cited by 0
Fiala, Martin · Brno University of Technology Digital Library (Brno University of Technology) · 2011
Tato práce se zabývá simulací průběhu signálu v zadané jednoduché struktuře s jedním regulátorem, řízenou soustavou a zpětnou vazbou pomocí open-source programovacího jazyka Python. V další části je rozebíráno generování C kódu regulátoru pro mikrokontroléry a následnou kontrolu průběhu signálu, který mikrokontrolér zpracovává. Tato kontrola je prováděna pomocí sériového rozhraní.
Cited by 0Open access
Conrad Jakob, P Beckett · RMIT Research Repository (RMIT University Library) · 2015
As we run to the end of the silicon roadmap, the rapidly escalating cost of design, fabrication and test in future systems-on-chip may justify a re- evaluation of homogeneous reconfigurable mesh ar- chitectures. Ultimately, the geometric constraints of extreme nanoscale device layout may support only simple functional arrays with predominately nearest neighbour connectivity. However, these have proved to be difficult to configure and program effectively as even small load imbalances, unnecessary synchroniza- tion overheads or delayed accesses to remote data can prevent typical applications from running efficiently on large distributed arrays of processors. We describe an approach to the problem of configuring a system- on-chip comprising an array of small interconnected processors that imposes a common structure on dis- tributed programs and trades some code efficiency for ease of programming and ease of verification. Zeta is a stack-based, concatenative language that bears some similarity to Forth. It has been developed to man- age the complexities of simulation and code genera- tion in this multi-coprocessor environment. Zeta pro- grams implement the computation and connections of directed acyclic graphs (DAGs) by manipulating a stack of state variables. State information can be passed forward (in time) through the directed acyclic graph as needed using a virtual bus construct. This paper describes the key features of the language and illustrates its use via an example implementation of an LDPC decoder.
Cited by 0
Wenhao Wang, Rong, Yi, Y. K. Li et al. · arXiv (Cornell University) · 2025
Recent advances in Large language models (LLMs) have demonstrated their promising capabilities of generating robot operation code to enable LLM-driven robots. To enhance the reliability of operation code generated by LLMs, corrective designs with feedback from the observation of executing code have been increasingly adopted in existing research. However, the code execution in these designs relies on either a physical experiment or a customized simulation environment, which limits their deployment due to the high configuration effort of the environment and the potential long execution time. In this paper, we explore the possibility of directly leveraging LLM to enable static simulation of robot operation code, and then leverage it to design a new reliable LLM-driven corrective robot operation code generation framework. Our framework configures the LLM as a static simulator with enhanced capabilities that reliably simulate robot code execution by interpreting actions, reasoning over state transitions, analyzing execution outcomes, and generating semantic observations that accurately capture trajectory dynamics. To validate the performance of our framework, we performed experiments on various operation tasks for different robots, including UAVs and small ground vehicles. The experiment results not only demonstrated the high accuracy of our static text-based simulation but also the reliable code generation of our LLM-driven corrective framework, which achieves a comparable performance with state-of-the-art research while does not rely on dynamic code execution using physical experiments or simulators.
Cited by 0Open access
Junting Chen, Yao Mu, Qiaojun Yu et al. · arXiv (Cornell University) · 2024
Rapid progress in high-level task planning and code generation for open-world robot manipulation has been witnessed in Embodied AI. However, previous studies put much effort into general common sense reasoning and task planning capabilities of large-scale language or multi-modal models, relatively little effort on ensuring the deployability of generated code on real robots, and other fundamental components of autonomous robot systems including robot perception, motion planning, and control. To bridge this ``ideal-to-real'' gap, this paper presents \textbf{RobotScript}, a platform for 1) a deployable robot manipulation pipeline powered by code generation; and 2) a code generation benchmark for robot manipulation tasks in free-form natural language. The RobotScript platform addresses this gap by emphasizing the unified interface with both simulation and real robots, based on abstraction from the Robot Operating System (ROS), ensuring syntax compliance and simulation validation with Gazebo. We demonstrate the adaptability of our code generation framework across multiple robot embodiments, including the Franka and UR5 robot arms, and multiple grippers. Additionally, our benchmark assesses reasoning abilities for physical space and constraints, highlighting the differences between GPT-3.5, GPT-4, and Gemini in handling complex physical interactions. Finally, we present a thorough evaluation on the whole system, exploring how each module in the pipeline: code generation, perception, motion planning, and even object geometric properties, impact the overall performance of the system.
Cited by 3Open access
Ali Nouri, Johan Andersson, Kailash De Jesus Hornig et al. · ArXiv.org · 2025
Automated Driving System (ADS) is a safety-critical software system responsible for the interpretation of the vehicle's environment and making decisions accordingly. The unbounded complexity of the driving context, including unforeseeable events, necessitate continuous improvement, often achieved through iterative DevOps processes. However, DevOps processes are themselves complex, making these improvements both time- and resource-intensive. Automation in code generation for ADS using Large Language Models (LLM) is one potential approach to address this challenge. Nevertheless, the development of ADS requires rigorous processes to verify, validate, assess, and qualify the code before it can be deployed in the vehicle and used. In this study, we developed and evaluated a prototype for automatic code generation and assessment using a designed pipeline of a LLM-based agent, simulation model, and rule-based feedback generator in an industrial setup. The LLM-generated code is evaluated automatically in a simulation model against multiple critical traffic scenarios, and an assessment report is provided as feedback to the LLM for modification or bug fixing. We report about the experimental results of the prototype employing Codellama:34b, DeepSeek (r1:32b and Coder:33b), CodeGemma:7b, Mistral:7b, and GPT4 for Adaptive Cruise Control (ACC) and Unsupervised Collision Avoidance by Evasive Manoeuvre (CAEM). We finally assessed the tool with 11 experts at two Original Equipment Manufacturers (OEMs) by conducting an interview study.
Cited by 0Open access
Vu, Fabian · Univ. Duesseldorf: Duesseldorfer Dokumenten- und Publikationsserver · 2025
Cited by 0
Carlo Bernaschina, Sara Comai, Piero Fraternali · 2017
The wide range of different platforms for web and mobile applications development requires fast prototyping and the evaluation of multiple releases. Model Driven Development (MDD) represents the application at high level with textual or visual languages and can be used to automatically generate the final product by means of model-to-model and model-to-code transformations. We describe IFMLEdit.org, an open-source, online MDD tool for the specification and automatic generation of fast prototypes of Web and mobile application from IFML (Interaction Flow Modeling Language) specifications. The tool also supports the semantic mapping from IFML to PCN, a variant of Petri Nets, for model simulation and checking.
Cited by 13
George Mitenkov, Ioannis Magkanaris, Omar Awile et al. · 2023
Advances in computational capabilities and large volumes of experimental data have established computer simulations of brain tissue models as an important pillar in modern neuroscience. Alongside, a variety of domain specific languages (DSLs) have been developed to succinctly express properties of these models, ensure their portability to different platforms, and provide an abstraction that allows scientists to work in their comfort zone of mathematical equations, delegating concerns about performance optimizations to downstream compilers. One of the popular DSLs in modern neuroscience is the NEURON MODeling Language (NMODL). Until now, its compilation process has been split into first transpiling NMODL to C++ and then using a C++ toolchain to emit the efficient machine code. This approach has several drawbacks including the reliance on different programming models to target heterogeneous hardware, maintainability of multiple compiler back-ends and the lack of flexibility to use the domain information for C++ code optimization. To overcome these limitations, we present MOD2IR, a new open-source code generation pipeline for NMODL. MOD2IR leverages the LLVM toolchain to target multiple CPU and GPU hardware platforms. Generating LLVM IR allows the vector extensions of modern CPU architectures to be targeted directly, producing optimized SIMD code. Additionally, this gives MOD2IR significant potential for further optimizations based on the domain information available when LLVM IR code is generated. We present experiments showing that MOD2IR is able to produce on-par execution performance using a single compiler back-end implementation compared to code generated via state-of-the-art C++ compilers, and can even surpass them by up to 1.26×. Moreover, MOD2IR supports JIT-execution of NMODL, yielding both efficient code and an on-the-fly execution workflow.
Cited by 1Open access
Tmp · 2008
Cited by 0