Cyberphysical systems (CPSs) are new class of engineered systems that offer close interaction between cyber and physical components. The field of CPS has been identified as a key area of research, and CPSs are expected to play a major role in the design and development of future systems. In this paper, we survey recent advancements made in the development and applications of CPSs. We classify the existing research work based on their characteristics and identify the future challenges. We also discuss the examples of prototypes of CPSs. The aim of this survey is to enable researchers and system designers to get insights into the working and applications of CPSs and motivate them to propose novel solutions for making wide-scale adoption of CPS a tangible reality.

Design Techniques and Applications of Cyberphysical Systems: A Survey

Writing accurate numerical software is hard because of many sources of unavoidable uncertainties, including finite numerical precision of implementations. We present a programming model where the user writes a program in a real-valued implementation and specification language that explicitly includes different types of uncertainties. We then present a compilation algorithm that generates a finite-precision implementation that is guaranteed to meet the desired precision with respect to real numbers. Our compilation performs a number of verification steps for different candidate precisions. It generates verification conditions that treat all sources of uncertainties in a unified way and encode reasoning about finite-precision roundoff errors into reasoning about real numbers. Such verification conditions can be used as a standardized format for verifying the precision and the correctness of numerical programs. Due to their non-linear nature, precise reasoning about these verification conditions remains difficult and cannot be handled using state-of-the art SMT solvers alone. We therefore propose a new procedure that combines exact SMT solving over reals with approximate and sound affine and interval arithmetic. We show that this approach overcomes scalability limitations of SMT solvers while providing improved precision over affine and interval arithmetic. Our implementation gives promising results on several numerical models, including dynamical systems, transcendental functions, and controller implementations.

http://lara.epfl.ch/~kuncak/papers/DarulovaKuncak14SoundCompilationReals.pdf

Sound compilation of reals

The concept of digital twin, a kind of virtual things with the precise states of the corresponding physical systems, is suggested by industrial domains to accurately estimate the status and predict the operation of machines. Digital twin can be used for development of critical systems, such as self-driving cars and auto-production factories. There, however, will be so different digital twins in terms of resolution, complexity, modelling languages and formats. It is required to cooperate heterogeneous digital twins in standardized ways. Since a centralized digital twin system uses too big resources and energies, it is preferable to make large-scale digital twin system geographically and logically distributed over the Internet. In addition, efficient interworking functions between digital twins and the physical systems are required also. In this paper, we propose a novel architecture of large-scale digital twin platform including distributed digital twin cooperation framework, flexible data-centric communication middleware, and the platform based digital twin application to develop a reliable advanced driver assistance system.

Data-centric middleware based digital twin platform for dependable cyber-physical systems

Performing computational experiments on mathematical models instead of building and testing physical prototypes can drastically reduce the develop cost for complex systems such as automobiles, airc ...

/pdf/meta-languages-and-semantics-for-equation-based-modeling-and-4pwoetf2rm.pdf

Meta-Languages and Semantics for Equation-Based Modeling and Simulation

Keynote- The Return of Transactions- Session I- A Model for Java with Wildcards- On Validity of Program Transformations in the Java Memory Model- Safe Cross-Language Inheritance- Session II- Liquid Metal: Object-Oriented Programming Across the Hardware/Software Boundary- Kilim: Isolation-Typed Actors for Java- A Uniform Transactional Execution Environment for Java- Session III- Ptolemy: A Language with Quantified, Typed Events- Prototyping and Composing Aspect Languages- Assessing the Impact of Aspects on Exception Flows: An Exploratory Study- Session IV- UpgradeJ: Incremental Typechecking for Class Upgrades- Integrating Nominal and Structural Subtyping- Flow Analysis of Code Customizations- Session V- Online Phase-Adaptive Data Layout Selection- MTM2: Scalable Memory Management for Multi-tasking Managed Runtime Environments- Externalizing Java Server Concurrency with CAL- Session VI- Regional Logic for Local Reasoning about Global Invariants- A Unified Framework for Verification Techniques for Object Invariants- Extensible Universes for Object-Oriented Data Models- Session VII- Programming with Live Distributed Objects- Bristlecone: A Language for Robust Software Systems- Session-Based Distributed Programming in Java- Session VIII- ReCrash: Making Software Failures Reproducible by Preserving Object States- An Extensible State Machine Pattern for Interactive Applications- Practical Object-Oriented Back-in-Time Debugging- Session IX- Inference of Reference Immutability- Computing Stack Maps with Interfaces- How Do Java Programs Use Inheritance? An Empirical Study of Inheritance in Java Software

ECOOP 2008 - object-oriented programming : 22nd European Conference, Paphos, Cyprus, July 7-11, 2008 : proceedings

Multi-stage programming (MSP) provides a disciplined approach to run-time code generation. In the purely functional setting, it has been shown how MSP can be used to reduce the overhead of abstractions, allowing clean, maintainable code without paying performance penalties. Unfortunately, MSP is difficult to combine with imperative features, which are prevalent in mainstream languages. The central difficulty is scope extrusion, wherein free variables can inadvertently be moved outside the scopes of their binders. This paper proposes a new approach to combining MSP with imperative features that occupies a "sweet spot" in the design space in terms of how well useful MSP applications can be expressed and how easy it is for programmers to understand. The key insight is that escapes (or "anti-quotes") must be weakly separable from the rest of the code, i.e. the computational effects occurring inside an escape that are visible outside the escape are guaranteed to not contain code. To demonstrate the feasibility of this approach, we formalize a type system based on Lightweight Java which we prove sound, and we also provide an implementation, called Mint, to validate both the expressivity of the type system and the effect of staging on the performance of Java programs.

Mint: Java multi-stage programming using weak separability

It is difficult to write parallel programs that are correct. This is because of the potential for data races , when parallel tasks access shared data in complex and unexpected ways. A classic approach to addressing this problem is dynamic race detection, which has the benefits of working transparently to the programmer and not raising any false alarms. Unfortunately, dynamic race detection is very slow in practice; further, it can only detect low-level races, not high-level races which are also known as atomicity violations . In this paper, we present a new approach to dynamic detection of data races and atomicity violations based on the concept of permission regions , which are regions of code that have permission to read or write certain variables. Dynamic checks are used to ensure that no conflicting permission regions execute in parallel, thereby allowing the granularity of checks to be adjusted according to the size of permission regions. We demonstrate that permission regions can be used to achieve significantly better performance than past work on dynamic race detection, to the point where they could be used to enable always on race detection for both low- and high-level races in production code.

https://www.cs.rice.edu/~vs3/PDF/rv11.pdf

Permission regions for race-free parallelism

An approximate program transformation is a transformation that can change the semantics of a program within a specified empirical error bound. Such transformations have wide applications: they can decrease computation time, power consumption, and memory usage, and can, in some cases, allow implementations of incomputable operations. Correctness proofs of approximate program transformations are by definition quantitative. Unfortunately, unlike with standard program transformations, there is as of yet no modular way to prove correctness of an approximate transformation itself. Error bounds must be proved for each transformed program individually, and must be re-proved each time a program is modified or a different set of approximations are applied. In this paper, we give a semantics that enables quantitative reasoning about a large class of approximate program transformations in a local, composable way. Our semantics is based on a notion of distance between programs that defines what it means for an approximate transformation to be correct up to an error bound. The key insight is that distances between programs cannot in general be formulated in terms of metric spaces and real numbers. Instead, our semantics admits natural notions of distance for each type construct; for example, numbers are used as distances for numerical data, functions are used as distances for functional data, an polymorphic lambda-terms are used as distances for polymorphic data. We then show how our semantics applies to two example approximations: replacing reals with floating-point numbers, and loop perforation.

pdf/a-semantics-for-approximate-program-transformations-35ogflbs8l.pdf

A Semantics for Approximate Program Transformations

Previous work on semantics-based multi-state programming language design focused on homogeneous and heterogeneous software designs. In homogenous software design, the source and the target software programming languages are the same. In heterogeneous software design, they are different software languages. This paper proposes a practical means to circuit design by providing specialized offshoring translations from subsets of the source software programming language to subsets of the target hardware description language (HDL). This approach avoids manually writing codes for specifying the circuit of the given algorithm. To illustrate the proposed approach, we design and implement a translation to a subset of Verilog suitable numerical and logical computation. Through the translator, programmers can specify abstract algorithms in high level languages and automatically convert them into circuit descriptions in low level languages.© 2010 Binary Information Press.

Implicitly Heterogeneous Multi-Stage Programming for FPGAs

Although name-bindings are ubiquitous in computer science, they are well-known to be cumbersome to encode and reason about in logic and type theory. There are many proposed solutions to this problem in the literature, but most of these proposals, however, have been extensional, meaning they are defined in terms of other concepts in the theory. This makes it difficult to apply these proposals in intensional theories like the Calculus of Inductive Constructions, or CIC.In this paper, we introduce an approach to encoding name-bindings that is intensional, as it attempts to capture the meaning of a name-binding in itself. This approach combines in a straightforward manner with CIC to form the Calculus of Nominal Inductive Constructions, or CNIC. CNIC supports induction over data containing bindings, comparing of names for equality, and associating meta-language types with names in a fashion similar to HOAS, features which have been shown difficult to support in practice.

/pdf/the-calculus-of-nominal-inductive-constructions-an-3gs2qtyj0s.pdf

The calculus of nominal inductive constructions: an intensional approach to encoding name-bindings

Handle everyday research tasks with reliable, citation-backed results

Your personal Research Agent to handle research tasks with citation-backed results

Popular Tasks used by Researchers

How can I help with your research?

Meet SciSpace

Get more enhanced response by uploading the PDFs you want me to reference.

No relevant PDFs in your library

SciSpace is the AI research assistant for academics. Run systematic literature reviews on 280M+ papers, and write papers with cited sources. Trusted by 1M+ students, PhDs & researchers.

SciSpace | AI for Research

Analyze PDFs

Code & Manuscripts

Funding & Grants

Literature & Patents

Medical & Clinical Data

Systematic Review

Visualize & Present

Web & Data

Build a Google Scholar-like website for your research.

Build a website

Create charts and images for your research

Create a Chart

Write a paper for submission to a journal

Draft a manuscript

Patent Search

Design eye-catching scientific posters in minutes.

Scientific Poster Generation

Systematic Literature Review

One task is running at the moment. Your messages will be shown right after.

Drag and drop or click here to browse

Loved by <highlight>1 million+</highlight> researchers

Extract a list of specific topics and their sources from unstructured text

Topics

Compare and analyze relevant papers that matches with your search

Papers

Get insights from PDFs and bookmarked papers from your library

My library

Recent searches

Try searching for:

Catch AI-generated content in scholarly and non-scholarly content

{ai} Detector

Ai Writer

Get PDF Summaries, highlighted text explanations 

Chat with PDF

Effortlessly create in-text citations and bibliographies in APA and 2,500 other formats

Citation generator

Get explanations, summaries, and answers on academic papers

Ease up your research workflow with {scispace}'s cohort of exciting AI tools

Elevate your academic writing skills and convey your ideas the way you want

Paraphraser

Explore our range of reading and writing tools

Your file is being prepared and should be ready in a few minutes. If it's a large file, it might take a bit longer. You can close this window, and we'll email you the file when it's done.

You have reached a maximum limit of <strong>{limit}</strong> columns in the table. Remove at least <strong>1</strong> column to add or create another one.

Edwin Westbrook

Author Tools

Chat about Author