Change search
Refine search result
12 1 - 50 of 61
CiteExportLink to result list
Permanent link
Cite
Citation style
  • apa
  • harvard1
  • ieee
  • modern-language-association-8th-edition
  • vancouver
  • Other style
More styles
Language
  • de-DE
  • en-GB
  • en-US
  • fi-FI
  • nn-NO
  • nn-NB
  • sv-SE
  • Other locale
More languages
Output format
  • html
  • text
  • asciidoc
  • rtf
Rows per page
  • 5
  • 10
  • 20
  • 50
  • 100
  • 250
Sort
  • Standard (Relevance)
  • Author A-Ö
  • Author Ö-A
  • Title A-Ö
  • Title Ö-A
  • Publication type A-Ö
  • Publication type Ö-A
  • Issued (Oldest first)
  • Issued (Newest first)
  • Created (Oldest first)
  • Created (Newest first)
  • Last updated (Oldest first)
  • Last updated (Newest first)
  • Disputation date (earliest first)
  • Disputation date (latest first)
  • Standard (Relevance)
  • Author A-Ö
  • Author Ö-A
  • Title A-Ö
  • Title Ö-A
  • Publication type A-Ö
  • Publication type Ö-A
  • Issued (Oldest first)
  • Issued (Newest first)
  • Created (Oldest first)
  • Created (Newest first)
  • Last updated (Oldest first)
  • Last updated (Newest first)
  • Disputation date (earliest first)
  • Disputation date (latest first)
Select
The maximal number of hits you can export is 250. When you want to export more records please use the Create feeds function.
  • 1.
    Aronsson, Peter
    et al.
    MathCore Engineering AB, Linköping, Sweden.
    Broman, David
    Linköpings universitet, PELAB - Laboratoriet för programmeringsomgivningar, Sweden.
    Extendable Physical Unit Checking with Understandable Error Reporting2009In: Proceedings of the 7th International Modelica Conference, Linköping: Linköping University Electronic Press, Linköpings universitet , 2009, p. 890-897Conference paper (Refereed)
    Abstract [en]

    Dimensional analysis and physical unit checking are important tools for helping users to detect and correct mistakes in dynamic mathematical models. To make tools useful in a broad range of domains, it is important to also support other units than the SI standard. For instance, such units are common in biochemical or financial modeling. Furthermore, if two or more units turn out be in conflict after checking, it is vital that the reported unit information is given in an understandable format for the user, e.g., “N.m” should preferably be shown instead of “m2.kg.s-2”, even if they represent the same unit. Presently, there is no standardized solution to handle these problems for Modelica models. The contribution presented in this paper is twofold. Firstly, we propose an extension to the Modelica language that makes it possible for a library designer to define both new base units and derived units within Modelica models and packets. Today this information is implicitly defined in the specification. Secondly, we describe and analyze a solution to the problem of presenting units to users in a more convenient way, based on an algorithm using Mixed Integer Programming (MIP). Both solutions are implemented, tested, and illustrated with several examples.

  • 2.
    Broman, David
    Linköpings universitet, PELAB - Laboratoriet för programmeringsomgivningar.
    Flow Lambda Calculus for Declarative Physical Connection Semantics2007Report (Other academic)
    Abstract [en]

    One of the most fundamental language constructs of equation-based object-oriented languages is the possibility to state acausal connections, where both potential variables and flow variables exist. Several of the state-of-the art languages in this category are informally specified using natural language. This can make the languages hard to interpret, reason about, and disable the possibility to guarantee the absence of certain errors. In this work, we construct a formal operational small-step semantics based on the lambda-calculus. The calculus is then extended with more convenient modeling capabilities. Examples are given that demonstrate the expressiveness of the language, and some tests are made to verify the correctness of the semantics.

  • 3.
    Broman, David
    Linköpings universitet, PELAB - Laboratoriet för programmeringsomgivningar.
    Growing an Equation-Based Object-Oriented Modeling Language2009In: Proceedings of the 6th Vienna International Conference on Mathematical Modelling (MATHMOD 2009 ), 2009, p. 1316-1324Conference paper (Other academic)
    Abstract [en]

    Equation-based object-oriented (EOO) modeling languages are typically rather complex. Such languages can unfortunately not be designed correctly once and for all, not least because all requirements and use cases are not known initially, and may never be known completely. Hence, there is a need to plan for modeling languages to grow in a sound manner. This paper discusses and analyzes how EOO languages in general can be designed for growth, and in particular how this relates to the evolution of the Modelica language. Different ways of growth are categorized and various stakeholders’ perspectives are discussed regarding what is important when growing a language.

  • 4.
    Broman, David
    University of California, Berkeley, USA.
    High-confidence cyber-physical co-design2012In: In Proceedings of the Work-in-Progress (WiP) session of the 33rd IEEE Real-Time Systems Symposium (RTSS'12), ACM , 2012Conference paper (Refereed)
    Abstract [en]

    Cyber-physical systems (CPS) [4] are characterized by combining computations, networks, and physical processes. Engineering cyber-physical systems is not new; high-end automobiles have for decades included complex embedded systems that interact with the physical environment. As an intellectual discipline, however, CPS design poses both new opportunities and challenges. The rapid development of a CPS with high-confidence of its functional correctness is a co-design problem---the design of the cyber part (embedded control systems and networks) and the physical part influence each other. For instance, when designing an industrial robot, the thickness of the robot arms changes the physical behavior of the system; thinner arms have less inertia and can move faster, but introduce more flexibility and spring behavior, making the control algorithm harder to design. As a consequence, to meet increasingly challenging systemlevel objectives, the cyber and physical parts need to be concurrently designed.

  • 5.
    Broman, David
    KTH, School of Electrical Engineering and Computer Science (EECS), Software and Computer systems, SCS.
    Hybrid Simulation Safety: Limbos and Zero Crossings2018In: Principles of Modeling: Essays Dedicated to Edward A. Lee on the Occasion of His 60th Birthday, Springer, 2018, p. 106-121Chapter in book (Refereed)
    Abstract [en]

    Physical systems can be naturally modeled by combining continuous and discrete models. Such hybrid models may simplify the modeling task of complex system, as well as increase simulation performance. Moreover, modern simulation engines can often efficiently generate simulation traces, but how do we know that the simulation results are correct? If we detect an error, is the error in the model or in the simulation itself? This paper discusses the problem of simulation safety, with the focus on hybrid modeling and simulation. In particular, two key aspects are studied: safe zero-crossing detection and deterministic hybrid event handling. The problems and solutions are discussed and partially implemented in Modelica and Ptolemy II.

  • 6.
    Broman, David
    Linköpings universitet, PELAB - Laboratoriet för programmeringsomgivningar.
    Meta-Languages and Semantics for Equation-Based Modeling and Simulation2010Doctoral thesis, monograph (Other academic)
    Abstract [en]

    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, aircraft, and powerplants. In the past three decades, a new category of equation-based modeling languages has appeared that is based on acausal and object-oriented modeling principles, enabling good reuse of models.  However, the modeling languages within this category have grown to be large and complex, where the specifications of the language's semantics are informally defined, typically described in natural languages. The lack of a formal semantics makes these languages hard to interpret unambiguously and to reason about. This thesis concerns the problem of designing the semantics of such equation-based modeling languages in a way that allows formal reasoning and increased correctness. The work is presented in two parts.

    In the first part we study the state-of-the-art modeling language Modelica.  We analyze the concepts of types in Modelica and conclude that there are two kinds of type concepts: class types and object types. Moreover, a concept called structural constraint delta is proposed, which is used for isolating the faults of an over- or under-determined model.

    In the second part, we introduce a new research language called the Modeling Kernel Language (MKL). By introducing the concept of higher-order acausal models (HOAMs), we show that it is possible to create expressive modeling libraries in a manner analogous to Modelica, but using a small and simple language concept. In contrast to the current state-of-the-art modeling languages, the semantics of how to use the models, including meta operations on models, are also specified in MKL libraries. This enables extensible formal executable specifications where important language features are expressed through libraries rather than by adding completely new language constructs. MKL is a statically typed language based on a typed lambda calculus. We define the core of the language formally using operational semantics and prove type safety.  An MKL interpreter is implemented and verified in comparison with a Modelica environment.

  • 7.
    Broman, David
    Linköpings universitet, PELAB - Laboratoriet för programmeringsomgivningar.
    Safety, Security, and Semantic Aspects of Equation-Based Object-Oriented Languages and Environments2007Licentiate thesis, comprehensive summary (Other academic)
    Abstract [en]

    During the last two decades, the interest for computer aided modeling and simulation of complex physical systems has witnessed a significant growth. The recent possibility to create acausal models, using components from different domains (e.g., electrical, mechanical, and hydraulic) enables new opportunities. Modelica is one of the most prominent equation-based object-oriented (EOO) languages that support such capabilities, including the ability to simulate both continuous- and discrete-time models, as well as mixed hybrid models. However, there are still many remaining challenges when it comes to language safety and simulation security. The problem area concerns detecting modeling errors at an early stage, so that faults can be isolated and resolved. Furthermore, to give guarantees for the absence of faults in models, the need for precise language specifications is vital, both regarding type systems and dynamic semantics.

    This thesis includes five papers related to these topics. The first paper describes the informal concept of types in the Modelica language, and proposes a new concrete syntax for more precise type definitions. The second paper provides a new approach for detecting over- and under-constrained systems of equations in EOO languages, based on a concept called structural constraint delta. That approach makes use of type checking and a type inference algorithm. The third paper outlines a strategy for using abstract syntax as a middle-way between a formal and informal language specification. The fourth paper suggests and evaluates an approach for secure distributed co-simulation over wide area networks. The final paper outlines a new formal operational semantics for describing physical connections, which is based on the untyped lambda calculus. A kernel language is defined, in which real physical models are constructed and simulated.

  • 8.
    Broman, David
    Linköpings universitet, PELAB - Laboratoriet för programmeringsomgivningar.
    Should Software Engineering Projects be the Backbone or the Tail of Computing Curricula?2010In: Software Engineering Education and Training (CSEE&T), 2010, IEEE , 2010, p. 153-156Conference paper (Refereed)
    Abstract [en]

    Most computer science (CS) and software engineering (SE) curricula include some form of SE project with the aim of lowering the gap between CS and SE education and real-world demands in industry. In this paper we briefly discuss and explain our findings of software engineering projects taught at LiU in Sweden. These courses use what we call the ¿tail¿ approach, where student projects are performed at the end of a degree program. We then argue that there are several problems with this approach and sketch an idea where SE projects are an integrated part of a curriculum. Furthermore, pros and cons of this idea, which we call the SE project ¿backbone¿ approach, are discussed and analyzed.

  • 9.
    Broman, David
    et al.
    Linköpings universitet, Institutionen för datavetenskap.
    Aronsson, Peter
    MathCore Engineering.
    Fritzson, Peter
    Linköpings universitet, Institutionen för datavetenskap.
    Design Considerations for Dimensional Inference and Unit Consistency Checking in Modelica2008In: Proceedings of the 6th International Modelica Conference, Bielefeld, Germany: Modelica Association , 2008, p. 3-12Conference paper (Refereed)
    Abstract [en]

    The Modelica language supports syntax for declaring physical units of variables, but it does not yet exist any defined semantics for how dimensional and unit consistency checking should be carried out. In this paper we explore different approaches and new constructs for improved dimensional inference and unit consistency checking in Modelica; both from an end-user, library, and tool perspective. A proposal for how dimensional inference and unit checking can be carried out is outlined and a prototype implementation is developed and verified using several examples from the Modelica standard library.

  • 10.
    Broman, David
    et al.
    University of California, Berkeley and Linköping University.
    Brooks, Christopher
    University of California, Berkeley.
    Greenberg, Lev
    IBM.
    Lee, Edward A.
    University of California, Berkeley.
    Masin, Michael
    IBM.
    Tripakis, Stavros
    University of California, Berkeley.
    Wetter, Michael
    LBNL, Berkeley.
    Determinate Composition of FMUs for Co-Simulation2013In: Proceedings of the International Conference on Embedded Software (EMSOFT 2013), IEEE conference proceedings, 2013, p. 1-12Conference paper (Refereed)
    Abstract [en]

    In this paper, we explain how to achieve deterministic execution of FMUs (Functional Mockup Units) under the FMI (Functional Mockup Interface) standard. In particular, we focus on co-simulation, where an FMU either contains its own internal simulation algorithm or serves as a gateway to a simulation tool. We give conditions on the design of FMUs and master algorithms (which orchestrate the execution of FMUs) to achieve deterministic co-simulation. We show that with the current version of the standard, these conditions demand capabilities from FMUs that are optional in the standard and rarely provided by an FMU in practice. When FMUs lacking these required capabilities are used to compose a model, many basic modeling capabilities become unachievable, including simple discrete-event simulation and variable-step-size numerical integration algorithms. We propose a small extension to the standard and a policy for designing FMUs that enables deterministic execution for a much broader class of models. The extension enables a master algorithm to query an FMU for the time of events that are expected in the future. We show that a model can be executed deterministically if all FMUs in the model are either memoryless or implement one of rollback or step-size prediction. We show further that such a model can contain at most one “legacy” FMU that is not memoryless and provides neither rollback nor step-size prediction.

  • 11.
    Broman, David
    et al.
    University of California, Berkeley.
    Derler, Patricia
    University of California, Berkeley.
    Desai, Ankush
    University of California, Berkeley.
    Eidson, John C.
    University of California, Berkeley.
    Seshia, Sanjit A.
    University of California, Berkeley.
    Endlessly Circulating Messages in IEEE 1588-2008 Systems2014In: Proceedings of the International IEEE Symposium on Precision Clock Synchronization for Measurement, Control and Communication (ISPCS 2014), IEEE conference proceedings, 2014, p. 7-12Conference paper (Refereed)
    Abstract [en]

    This paper studies conditions where messages endlessly circulate in a system of IEEE 1588-2008clocks. The study is based on two independent analysis techniques. One uses a discrete event simulation environment for describing the operation of the best master clock (BMC) algorithm inIEEE 1588-2008. The second uses a model checking tool. We discuss several cases illustrating conditions under which circulating messages occur and the effectiveness of measures to squelch these messages. This paper demonstrates that one or more of the squelching mechanisms must be implemented.

  • 12.
    Broman, David
    et al.
    University of California, Berkeley, USA.
    Derler, Patricia
    University of California, Berkeley.
    John C., Eidson
    University of California, Berkeley.
    Temporal Issues in Cyber-Physical Systems2013In: Journal of Indian Institute of Science, ISSN 0970-4140, Vol. 93, no 3, p. 389-402Article in journal (Refereed)
    Abstract [en]

    This paper reviews the use of time, clocks, and clock synchronization protocols in cyber-physical systems (CPS). Recent advances in the area of timing suggest avenues of research and potential new application areas. We discuss how introducing timestamps and clocks can help overcome issues such as latency, jitter, and determining correct execution order. Furthermore, we show how system complexity can be reduced and distribution as well as parallelism can be done deterministically. We also point to recent work in raising time to first class citizen status in modeling and implementation. In particular, we describe design and execution environments of CPS and specialized hardware such as predictable timing architectures where time plays a key role.

  • 13.
    Broman, David
    et al.
    Linköpings universitet, Institutionen för datavetenskap.
    Fritzson, Peter
    Linköpings universitet, Institutionen för datavetenskap.
    Abstract Syntax Can Make the Definition of Modelica Less Abstract2007In: Proceedings of the 1st International Workshop on Equation-Based Object-Oriented Languages and Tools, Berlin, Germany, 2007, p. 111-126Conference paper (Refereed)
    Abstract [en]

    Modelica is an open standardized language used for modeling and simulation of complex physical systems. The language specification defines a formal concrete syntax, but the semantics is informally described using natural language. The latter makes the language hard to interpret, maintain and reason about, which affect both tool development and language evolution. Even if a completely formal semantics of the Modelica language can be seen as a natural goal, it is a well-known fact that defining understandable and concise formal semantics specifications for large and complex languages is a very hard problem. In this paper, we will discuss different aspects of formulating a Modelica specification; both in terms of what should be specified and how it can be done. Moreover, we will further argue that a “middle-way” strategy can make the specification both clearer and easier to reason about. A proposal is outlined, where the current informally specified semantics is complemented with several grammars, specifying intermediate representations of abstract syntax. We believe that this kind of evolutionary strategy is easier to gain acceptance for, and is more realistic in the short-term, than a revolutionary approach of using a fully formal semantics definition of the language.

  • 14.
    Broman, David
    et al.
    Linköpings universitet, Institutionen för datavetenskap.
    Fritzson, Peter
    Linköpings universitet, Institutionen för datavetenskap.
    High-Order Acausal Models2009In: Simulation News Europe, ISSN 0929-2268, Vol. 19, no 1Article in journal (Refereed)
    Abstract [en]

    Current equation-based object-oriented (EOO) languages typically contain a number of fairly complex language constructs for enabling reuse of models. However, support for model transformation is still often limited to scripting solutions provided by tool implementations. In this paper we investigate the possibility of combining the well known concept of higher-order functions, used in standard functional programming languages, with acausal models. This concept, called Higher-Order Acausal Models (HOAMs), simplifies the creation of reusable model libraries and model transformations within the modeling language itself. These transformations include general model composition and recursion operations and do not require data representation/ reification of models as in metaprogramming/metamodeling. Examples within the electrical and mechanical domain are given using a small research language. However, the language concept is not limited to a particular language, and could in the future be incorporated into existing commercially available EOO-languages.

  • 15.
    Broman, David
    et al.
    Linköpings universitet, Institutionen för datavetenskap.
    Fritzson, Peter
    Linköpings universitet, Institutionen för datavetenskap.
    Ideas for Security Assurance in Security Critical Software using Modelica2005Conference paper (Refereed)
    Abstract [en]

    Due to the increasing number of vulnerabilities in software systems and customers- need to trust the producers- development process, third party security evaluations, such as Common Criteria (CC), are today commonly used to provide assurance of security critical software. Modelica is a modern, strongly typed, declarative, and object-oriented language for modeling and simulation of complex systems. In this paper we sketch two ideas for improving security assurance, by expanding the scope of Modelica into also becoming a declarative modeling language for other application areas than simulation.

  • 16.
    Broman, David
    et al.
    Linköpings universitet, Institutionen för datavetenskap.
    Fritzson, Peter
    Linköpings universitet, Institutionen för datavetenskap.
    Furic, Sébastien
    Imagine, France.
    Types in the Modelica Language2006In: Proceedings of the Fifth International Modelica Conference, 2006, p. 303-315Conference paper (Refereed)
    Abstract [en]

    Modelica is an object-oriented language designed for modeling and simulation of complex physical systems. To enable the possibility for an engineer to discover errors in a model, languages and compilers are making use of the concept of types and type checking. This paper gives an overview of the concept of types in the context of the Modelica language. Furthermore, a new concrete syntax for describing Modelica types is given as a starting point to formalize types in Modelica. Finally, it is concluded that the current state of the Modelica language specification is too informal and should in the long term be augmented by a formal definition.

     

  • 17.
    Broman, David
    et al.
    Linköpings universitet, PELAB - Laboratoriet för programmeringsomgivningar.
    Fritzson, Peter
    Linköpings universitet, Programvara och system.
    Hedin, Görel
    Lund University, Sweden.
    Åkesson, Johan
    Lund University, Sweden.
    A comparison of two metacompilation approaches to implementing a complex domaispecific language2012In: Proceedings of the 27th Annual ACM Symposium on Applied Computing (SAC), 2012, p. 1919-1921Conference paper (Refereed)
    Abstract [en]

    Operational semantics and attribute grammars are examples of formalisms that can be used for generating compilers. We are interested in finding similarities and differences in how these approaches are applied to complex languages, and for generating compilers of such maturity that they have users in industry.

    As a specific case, we present a comparative analysis of two compilers for Modelica, a language for physical modeling, and which contains numerous compilation challenges. The two compilers are OpenModelica, which is based on big-step operational semantics, and JModelica.org, which is based on reference attribute grammars.

  • 18.
    Broman, David
    et al.
    KTH, School of Information and Communication Technology (ICT), Software and Computer systems, SCS. UC Berkeley.
    Greenberg, Lev
    IBM.
    Lee, Edward A.
    University of California, Berkeley.
    Masin, Michael
    IBM.
    Tripakis, Stavros
    University of California, Berkeley and Aalto University.
    Wetter, Michael
    Lawrence Berkeley National Laboratory.
    Requirements for Hybrid Cosimulation Standards2015In: Proceedings of 18th ACM International Conference on Hybrid Systems: Computation and Control (HSCC), ACM Digital Library, 2015, p. 179-188Conference paper (Refereed)
    Abstract [en]

    This paper defines a suite of requirements for future hybrid cosimulation standards, and specifically provides guidance for development of a hybrid cosimulation version of the Functional Mockup Interface (FMI). A cosimulation standard defines interfaces that enable diverse simulation tools to interoperate. Specifically, one tool defines a component that forms part of a simulation model in another tool. We focus on components with inputs and outputs that are functions of time, and specifically on mixtures of discrete events and continuous time signals. This hybrid mixture is not well supported by existing cosimulation standards, and specifically not by FMI 2.0, for reasons that are explained in this paper. The paper defines a suite of test components, giving a mathematical model of an ideal behavior, plus a discussion of practical implementation considerations. The discussion includes acceptance criteria by which we can determine whether a standard supports definition of each component. In addition, we define a set of test compositions that define requirements for coordination between components, including consistent handling of timed events.

  • 19.
    Broman, David
    et al.
    Linköping University, Sweden.
    Karsai, GaborVanderbilt University.
    Proceedings of the 4th Analytic Virtual Integration of Cyber-Physical Systems Workshop2013Conference proceedings (editor) (Other academic)
  • 20.
    Broman, David
    et al.
    University of California, Berkeley and Linköping University.
    Lee, Edward A.
    University of California, Berkeley.
    Tripakis, Stavros
    University of California, Berkeley.
    Törngren, Martin
    KTH, School of Industrial Engineering and Management (ITM), Machine Design (Dept.), Mechatronics.
    Viewpoints, Formalisms, Languages, and Tools for Cyber-Physical Systems2012In: Proceedings of the 6th International Workshop on Multi-Paradigm Modeling (MPM), Association for Computing Machinery (ACM), 2012, p. 49-54Conference paper (Refereed)
    Abstract [en]

    Cyber-physical systems (CPS) are becoming indispensable in our modern way of life. As an application domain CPS is not new. As an intellectual discipline, however, it is. This paper focuses on CPS modeling, which is an essential activity in CPS design, with multiple challenges. In particular, stakeholders lack a systematic framework and guidelines to help them choose among the many available modeling languages and tools. We propose such a framework in this paper. Our framework consists of three elements: viewpoints, which capture the stakeholders’ interests and concerns; concrete languages and tools, among which the stakeholders must make a selection when defining their CPS design environments; and abstract, mathematical formalisms, which are the “semantic glue” linking the two worlds. As part of the framework, we survey various formalisms, languages, and tools and explain how they are related. We also provide examples of viewpoints and discuss how they are related to formalisms.

  • 21.
    Broman, David
    et al.
    Linköpings universitet, PELAB - Laboratoriet för programmeringsomgivningar, Sweden.
    Nilsson, Henrik
    University of Nottingham, England.
    Node-Based Connection Semanticsfor Equation-Based Object-Oriented Modeling Languages2012In: Proceedings of Fourteenth International Symposium on Practical Aspects of Declarative Languages (PADL 2012), 2012, p. 258-272Conference paper (Refereed)
    Abstract [en]

    Declarative, Equation-Based Object-Oriented (EOO) modeling languages, like Modelica, support modeling of physical systems by composition of reusable component models. An important application area is modeling of cyber-physical systems. EOO languages typically feature a connection construct allowing component models to be assembled into systems much like physical components are. Different designs are possible. This paper introduces, formalizes, and validates an approach based on explicit nodes that expressly is designed to work for functional EOO languages supporting higher-order modeling. The paper also considers Modelica-style connections and explains why that design does not work for functional EOO languages, thus mapping out the design space.

  • 22.
    Broman, David
    et al.
    Linköpings universitet, Institutionen för datavetenskap, Sweden.
    Nyström, Kaj
    Linköpings universitet, Institutionen för datavetenskap, Sweden.
    Fritzson, Peter
    Linköpings universitet, Institutionen för datavetenskap, Sweden.
    Determining Over- and Under-Constrained Systems of Equations using Structural Constraint Delta2006In: Proceedings of the 5th International Conference on Generative Programming and Component Engineering, 2006, p. 151-160Conference paper (Refereed)
    Abstract [en]

    Computer aided modeling and simulation of complex physical systems, using components from multiple application domains, such as electrical, mechanical, and hydraulic, have in recent years witnessed a significant growth of interest. In the last decade, equation-based object-oriented (EOO) modeling languages, (e.g. Modelica, gPROMS, and VHDL-AMS) based on acausal modeling using Differential Algebraic Equations (DAEs), have appeared. With such languages, it is possible to model physical systems at a high level of abstraction by using reusable components.A model in an EOO language needs to have the same number of equations as unknowns. A previously unsolved problem concerning this property is the efficient detection of over- or under-constrained models in the case of separately compiled models.This paper describes a novel technique to determine over- and under-constrained systems of equations in models, based on a concept called structural constraint delta. In many cases it is also possible to locate the source of the constraint-problem. Our approach makes use of static type checking and consists of a type inference algorithm. We have implemented it for a subset of the Modelica language, and successfully validated it on several examples.

  • 23.
    Broman, David
    et al.
    KTH, School of Information and Communication Technology (ICT), Software and Computer systems, SCS. UC Berkeley.
    Pepper, PeterTechnische Universtität Berlin, Germany.
    Proceedings of the 6th International Workshop on Equation-Based Object-Oriented Modeling Languages and Tools2014Conference proceedings (editor) (Other academic)
  • 24.
    Broman, David
    et al.
    Linköpings universitet, PELAB - Laboratoriet för programmeringsomgivningar, Sweden.
    Sandahl, Kristian
    Linköpings universitet, PELAB - Laboratoriet för programmeringsomgivningar, Sweden .
    How can we make software engineering text books well-founded, up-to-date, and accessible to students?2011In: Proceedings of the 24th IEEE-CS Conference on Software Engineering Education and Training (CSEE&T 2011),, IEEE , 2011, p. 386-390Conference paper (Refereed)
    Abstract [en]

    When teaching software engineering courses it is highly important to have good text books that are well-founded, up-to-date, and easily accessible to students. However, currently available text books on the market are either very broad or highly specialized, making it hard to select appropriate books for specific software engineering courses. Moreover, due to the rapidly changing subject of software engineering, books tend to become obsolete, which make students hesitate to buy books even if they are part of the listed course literature. In this paper, we briefly explain and discuss an approach of using a web-based system for creating collaborative and peer-reviewed text books that can be customized individually for specific courses. We describe and discuss the proposed system from a use case perspective.

  • 25.
    Broman, David
    et al.
    Linköping University.
    Sandahl, Kristian
    Linköping University.
    Abu Baker, Mohamed
    Linköping University.
    The Company Approach to Software Engineering Project Courses2012In: IEEE Transactions on Education, ISSN 0018-9359, E-ISSN 1557-9638, Vol. 55, no 4, p. 445-452Article in journal (Refereed)
    Abstract [en]

    Teaching larger software engineering project courses at the end of a computing curriculum is a way for students to learn some aspects of real-world jobs in industry. Such courses, often referred to as capstone courses, are effective for learning how to apply the skills they have acquired in, for example, design, test, and configuration management. However, these courses are typically performed in small teams, giving only a limited realistic perspective of problems faced when working in real companies. This paper describes an alternative approach to classic capstone projects, with the aim of being more realistic from an organizational, process, and communication perspective. This methodology, called the company approach, is described by intended learning outcomes, teaching/learning activities, and assessment tasks. The approach is implemented and evaluated in a larger Master's student course.

  • 26.
    Broman, David
    et al.
    KTH, School of Electrical Engineering and Computer Science (EECS), Software and Computer systems, SCS.
    Siek, J. G.
    United States.
    Gradually typed symbolic expressions2017In: PEPM 2018 - Proceedings of the ACM SIGPLAN Workshop on Partial Evaluation and Program Manipulation, Co-located with POPL 2018, Association for Computing Machinery (ACM), 2017, p. 15-29Conference paper (Refereed)
    Abstract [en]

    Embedding a domain-specific language (DSL) in a general purpose host language is an efficient way to develop a new DSL. Various kinds of languages and paradigms can be used as host languages, including object-oriented, functional, statically typed, and dynamically typed variants, all having their pros and cons. For deep embedding, statically typed languages enable early checking and potentially good DSL error messages, instead of reporting runtime errors. Dynamically typed languages, on the other hand, enable flexible transformations, thus avoiding extensive boilerplate code. In this paper, we introduce the concept of gradually typed symbolic expressions that mix static and dynamic typing for symbolic data. The key idea is to combine the strengths of dynamic and static typing in the context of deep embedding of DSLs. We define a gradually typed calculus <*>, formalize its type system and dynamic semantics, and prove type safety. We introduce a host language called Modelyze that is based on <*>, and evaluate the approach by embedding a series of equation-based domain-specific modeling languages, all within the domain of physical modeling and simulation.

  • 27.
    Broman, David
    et al.
    University of California, Berkeley, USA.
    Siek, Jeremy G.
    University of Colorado at Boulder, USA.
    Modelyze: a Gradually Typed Host Language for Embedding Equation-Based Modeling Languages2012Report (Other academic)
    Abstract [en]

    Equation-based modeling languages provide an effective means to simulate the physical part of a cyber-physical system. Such languages are complex domain-specific languages that enable model engineers, such as mechanical engineers, to declaratively model the dynamics of systems. However, these modeling languages do not support all modeling needs, which has lead to frequent revisions of state-of-the-art languages. In this article we explore a solution to this extensibility problem based on domain-specific embedded languages. We introduce a host language, named Modelyze, in which modeling languages may be easily embedded. The key features of Modelyze are first-class functions, which provide a mechanism to abstract components of a model, and symbolic expressions, to represent and manipulate equations. The type system for symbolic expressions supports model-level static error checking and provides an automatic lifting translation to provide seamless integration between the host language and the equations represented by symbolic expressions. The type system is based on gradual typing, enabling early static checking for model engineers while providing expressiveness for domain experts. We evaluate this approach by embedding a series of equation-based modeling languages in Modelyze and using them to develop models.

  • 28. Broman, David
    et al.
    Zimmer, Michael
    University of California, Berkeley .
    Kim, Yooseong
    Arizona State University.
    Kim, Hokeun
    University of California, Berkeley .
    Cai, Jian
    Arizona State University.
    Shrivastava, Aviral
    Arizona State University.
    Edwards, Stephen A.
    Columbia University.
    Lee, Edward A.
    University of California, Berkeley .
    Precision Timed Infrastructure: Design Challenges2013In: Proceedings of the Electronic System Level Synthesis Conference (ESLsyn), IEEE conference proceedings, 2013Conference paper (Refereed)
    Abstract [en]

    In general-purpose software applications, computation time is just a quality factor: faster is better. In cyber-physical systems (CPS), however, computation time is a correctness factor: missed deadlines for hard real-time applications, such as avionics and automobiles, can result in devastating, life-threatening consequences. Although many modern modeling languages for CPS include the notion of time, implementation languages such as C lack any temporal semantics. Consequently, models and programs for CPS are neither portable nor guaranteed to execute correctly on the real system; timing is merely a side effect of the realization of a software system on a specific hardware platform. In this position paper, we present the research initiative for a precision timed (PRET) infrastructure, consisting of languages, compilers, and microarchitectures, where timing is a correctness factor. In particular, the timing semantics in models and programs must be preserved during compilation to ensure that the behavior of real systems complies with models. We also outline new research and design challenges present in such an infrastructure.

  • 29.
    Cellier, François
    et al.
    ETH Zürich.
    Broman, DavidLinköpings universitet, Institutionen för datavetenskap.Fritzson, PeterLinköpings universitet, Institutionen för datavetenskap.Lee, EdwardUniversity of California, Berkeley.
    Proceedings of the 4th International Workshop on Equation-Based Object-Oriented Modeling Languages and Tools2011Conference proceedings (editor) (Other academic)
  • 30. Cremona, F.
    et al.
    Lee, E. A.
    Lohstroh, M.
    Masin, M.
    Broman, David
    KTH, School of Electrical Engineering and Computer Science (EECS), Software and Computer systems, SCS.
    Tripakis, S.
    Hybrid Co-simulation: It's about time2018In: Proceedings - 21st ACM/IEEE International Conference on Model Driven Engineering Languages and Systems, MODELS 2018, Association for Computing Machinery, Inc , 2018Conference paper (Refereed)
    Abstract [en]

    Model-based design methodologies are commonly used in industry for the development of cyber-physical systems (CPSs). There are many different languages, tools, and formalisms for model-based design, each with its strengths and weaknesses. Instead of accepting the weaknesses of a particular tool, an alternative is to embrace heterogeneity and develop tool integration platforms and protocols to leverage the strengths from other environments. A fairly recent attempt in this direction is an open interface standard called Functional Mock-up Interface (FMI), which is focused on the convenient exchange and co-simulation of simulation models (Functional Mock-up Units, FMUs), primarily between component suppliers and OEMs. As it stands, FMI has reached acceptance in industry, but its specification (version 2.0) provides only limited support for hybrid co-simulation-simulating systems that mix continuous and discrete behaviors, which are commonly used to model CPSs. This paper identifies FMI's time representation based on floating-point numbers as a key problem, because it does not support well the discrete events that typically occur at the cyber-physical boundary; it is only suitable for modeling continuous dynamics without discrete behaviors. While time is a central concept in reasoning about the physical world, it is largely abstracted away when reasoning about the cyber world. As a result, the engineering methods for CPSs have misaligned abstractions between the physics domain, the mathematical domain used to model physics, the computational domain used to implement these mathematical abstractions for simulation, and the computational domain used on the cyber side of CPSs. The most common resolution for this conundrum is to adopt the naive Newtonian ideal model of time, where time is a real number known everywhere and advancing uniformly. But ironically, Newtonian time proves not so practical for hybrid co-simulation. The obvious reason is that digital computers do not work with real numbers. Whereas real numbers have infinite precision, their floating-point representation does not. This discrepancy leads to unpredictable quantization errors that may accumulate. Although real numbers can be compared for equality (e.g., to define “simultaneity”), it rarely makes sense to do so for floating-point numbers. We show that the approach taken in FMI (and many other modeling frameworks) that embraces a naive Newtonian physical model of time, and a cyber-approximation of this model using floating-point numbers, is inadequate for CPSs; it leads to models with unnecessarily inexplicable, nondeterministic, and complex behaviors. Our analysis concludes that a model of time that solely uses integers solves many of these problems. Specifically, we propose to use a 64-bit unsigned integer representation with arbitrary resolution, given as a power of ten, allowing model parameters specified in decimal to be represented exactly (granted ample resolution). Integer arithmetic is computationally efficient, and, for well-chosen resolutions, this representation will tolerate very long simulations without overflow. It is also easily converted to and from floating-point representations, albeit not losslessly. Given the vast range of time scales used across different simulation models, we believe that choosing a fixed universal time resolution does not make sense. Instead, we describe an algorithm that picks an adequate time resolution for a particular model and we provide procedures for time quantization needed to reconcile discrepacies between internal time representations of co-simulated FMUs. We propose concrete extensions to the FMI standard for the support of hybrid co-simulation that enable the use of integer time, automatic choice of time resolution, and the use of absent signals. We explain in detail how these extensions can be implemented mod-ularly within the frameworks of existing simulation environments and with support for legacy FMUs and superdense time.

  • 31.
    Cremona, Fabio
    et al.
    University of California Berkeley, Scuola Superiore Sant’Anna, ALES .
    Lohstroh, Marten
    University of California, Berkeley.
    Broman, David
    KTH, School of Information and Communication Technology (ICT), Software and Computer systems, SCS.
    Di Natale, Marco
    Scuola Superiore Sant’Anna.
    Lee, Edward
    University of California, Berkeley.
    Stavros, Tripakis
    University of California, Berkeley and Aalto University.
    Step Revision in Hybrid Co-simulation with FMI2016In: Proceedings of the 14th ACM-IEEE International Conference on formal Methods and Models for System Design (MEMOCODE), IEEE conference proceedings, 2016Conference paper (Refereed)
    Abstract [en]

    This paper presents a master algorithm for co-simulation of hybrid systems using the Functional Mock-up Interface (FMI) standard. Our algorithm introduces step revision to achieve an accurate and precise handling of mixtures of continuous-time and discrete-event signals, particularly in the situation where components are unable to accurately extrapolate their input. Step revision provides an efficient means to respect the error bounds of numerical approximation algorithms that operate inside co-simulated FMUs. We first explain the most fundamental issues associated with hybrid co-simulation and analyze them in the framework of FMI. We demonstrate the necessity for step revision to address some of these issues and formally describe a master algorithm that supports it. Finally, we present experimental results obtained through our reference implementation that is part of our publicly available open-source toolchain called FIDE.

  • 32.
    Desai, Ankush
    et al.
    University of California, Berkeley.
    Seshia, Sanjit A.
    University of California, Berkeley.
    Qadeer, Shaz
    Microsoft Research.
    Broman, David
    KTH, School of Information and Communication Technology (ICT), Software and Computer systems, SCS. KTH Royal Institute of Technology and University of California, Berkeley.
    Eidson, John C.
    University of California, Berkeley.
    Approximate synchrony: An abstraction for distributed almost-synchronous systems2015In: Proceedings of the 27th International Conference on Computer Aided Verification, CAV 2015, Springer, 2015, p. 429-448Conference paper (Refereed)
    Abstract [en]

    Forms of synchrony can greatly simplify modeling, design, and verification of distributed systems. Thus, recent advances in clock synchronization protocols and their adoption hold promise for system design. However, these protocols synchronize the distributed clocks only within a certain tolerance, and there are transient phases while synchronization is still being achieved. Abstractions used for modeling and verification of such systems should accurately capture these imperfections that cause the system to only be “almost synchronized.” In this paper, we present approximate synchrony, a sound and tunable abstraction for verification of almost-synchronous systems. We show how approximate synchrony can be used for verification of both time synchronization protocols and applications running on top of them. We provide an algorithmic approach for constructing this abstraction for symmetric, almost-synchronous systems, a subclass of almost-synchronous systems. Moreover, we show how approximate synchrony also provides a useful strategy to guide state-space exploration. We have implemented approximate synchrony as a part of a model checker and used it to verify models of the Best Master Clock (BMC) algorithm, the core component of the IEEE 1588 precision time protocol, as well as the time-synchronized channel hopping protocol that is part of the IEEE 802.15.4e standard.

  • 33.
    Fritzson, Peter
    et al.
    Linköping University.
    Aronsson, Peter
    Linköping University.
    Lundvall, Håkan
    Linköping University.
    Nyström, Kaj
    Linköping University.
    Pop, Adrian
    Linköping University.
    Saldamli, Levon
    Linköping University.
    Broman, David
    Linköping University.
    The OpenModelica Modeling, Simulation, and Software Development Environment2005In: Simulation News Europe, ISSN 0929-2268, Vol. 44, p. 8-16Article in journal (Refereed)
  • 34.
    Fritzson, Peter
    et al.
    Linköpings universitet, Institutionen för datavetenskap.
    Broman, David
    Linköpings universitet, Institutionen för datavetenskap.
    Cellier, Francois
    Nytsch Geusen, Christoph
    Equation-based object-oriented languages and tool: Report on the Workshop EOOLT 2007 at ECOOP 20072007In: Object-Oriented Technology, Springer, 2007, p. 27-39Chapter in book (Other academic)
    Abstract [en]

    EOOLT'2007 was the first edition of the ECOOP-EOOLT workshop. ne workshop is intended to bring researchers associated with different equation-based object-oriented (EOO) modeling languages and different application areas making use of such languages together. The aim of the workshop is to explore common grounds and derive software design principles that may make future EOO modeling languages more robust, more versatile, and more widely accepted among the various stakeholders. At EOOLT'2007, nineteen researchers with diverse backgrounds and needs came together to present and discuss fourteen different concept papers grouped into the four topic areas of integrated system modeling approaches; hybrid modeling and variable structure systems; modeling languages, specification, and language comparison; and tools and methods.

  • 35.
    Fritzson, Peter
    et al.
    Linköpings universitet, PELAB - Laboratoriet för programmeringsomgivningar.
    Broman, David
    Linköpings universitet, PELAB - Laboratoriet för programmeringsomgivningar.
    Cellier, François
    ETH Zurich, Switzerland.
    Equation-based object-oriented languages and tools: Report on the 2nd workshop EOOLT at ECOOP 20082009In: Object-Oriented Technology / [ed] Patrick Eugster, Springer Berlin/Heidelberg , 2009, 1, p. 18-29Chapter in book (Other academic)
    Abstract [en]

    EOOLT2008 was the second edition of the ECOOP-EOOLT workshop. The workshop is intended to bring researchers associated with different equation-based object-oriented (EOO) modeling languages and different application areas making use of such languages together. The aim of the workshop is to explore common grounds and derive software design principles that may make future EOO modeling languages more robust, more versatile, and more widely accepted among the various stakeholders. At EOOLT2008, researchers with diverse backgrounds and needs came together to present and discuss fourteen different concept papers grouped into the four topic areas of integrated system modeling approaches; modeling for multiple applications; modeling language design, and equation handling, diagnosis, and modeling.

  • 36.
    Fritzson, Peter
    et al.
    Linköpings universitet, Institutionen för datavetenskap.
    Cellier, FrançoisETH Zürich.Broman, DavidLinköpings universitet, Institutionen för datavetenskap.
    Proceedings of the 2nd International Workshop on Equation-Based Object-Oriented Languages and Tools2008Conference proceedings (editor) (Other academic)
  • 37.
    Fritzson, Peter
    et al.
    Linköpings universitet, Institutionen för datavetenskap.
    Lee, Edward
    University of California, Berkeley.
    Cellier, Francois
    ETH Zürich.
    Broman, David
    Linköpings universitet, Institutionen för datavetenskap.
    Equation-based object-oriented modeling languages and tools: Report on the workshop EOOLT 2010 at MODELS 2010 Oslo, Norway, October 3, 20102011In: Models in Software Engineering, Springer , 2011, p. 140-144Chapter in book (Other academic)
    Abstract [en]

    EOOLT 2010 was the third edition of the EOOLT workshop series. The workshop is intended to bring together researchers and practitioners fromdifferent equation-based object-oriented (EOO) modeling language communities. This year’s workshop also expands the scope to include the whole design space of languages for cyber-physical systems, where physical dynamics are mixed with networks and software. The workshop gathered 31 participants to present and discuss thirteen different papers grouped into the four areas of real-time oriented modeling languages and tools, modeling language design, simulation and model compilation, and modeling and simulation tools.

  • 38.
    Fritzson, Peter
    et al.
    Linköpings universitet, Institutionen för datavetenskap.
    Lee, EdwardUniversity of California, Berkeley.Cellier, FrançoisETH Zürich.Broman, DavidLinköpings universitet, Institutionen för datavetenskap.
    Proceedings of the 3rd International Workshop on Equation-Based Object-Oriented Modeling Languages and Tools, EOOLT 2010: In Conjunction with MODELS 20102010Conference proceedings (editor) (Other academic)
  • 39.
    Fritzson, Peter
    et al.
    Linköpings universitet, Institutionen för datavetenskap.
    Pop, Adrian
    Linköpings universitet, Institutionen för datavetenskap.
    Broman, David
    Linköpings universitet, Institutionen för datavetenskap.
    Aronsson, Peter
    Linköpings universitet, Institutionen för datavetenskap.
    Formal Semantics Based Translator Generation and Tool Development in Practice2009In: Proceedings of  20th Australian Software Engineering Conference (ASWEC 2009), IEEE Computer Society, 2009, p. 256-266Conference paper (Refereed)
    Abstract [en]

    In this paper we report on a long-term research effort to develop and use efficient language implementation generators in practice. The generator is applied to a number of different languages, some of which are used for projects in industry. The used formal specification style is operational semantics, primarily in the form called natural semantics, represented and supported by a meta-language and tool called the relational meta language (RML), which can generate efficient implementations in C, on par with hand-implemented code. Generating implementations from formal specifications are assumed to give advantages such as: high level descriptions, higher degree of correctness, and consistency between specification and implementation. To what extent can this be realized in practice? Does it scale to large language implementations? To answer some of these questions we have developed specifications of a range of languages: imperative, functional, object-oriented (Java), and equation-based (Modelica). The size of specifications range from half a page to large specifications of 60 000 lines. It turns out to be possible to generate efficient compilers, also for large languages. However, the performance of the generator tool and the user support of the development environment become increasingly important for large specifications. To satisfy such user needs the speed of the generator was increased a factor of ten to reduce turn-around time, and an Eclipse plug-in including a debugger were developed. For very large specifications, the structuring and modularity of the specification itself also become essential for performance and maintainability.

  • 40.
    Fuhrmann, Insa
    et al.
    Christian-Albrechts-Universität zu Kiel.
    Broman, David
    University of California, Berkeley and Linköping University.
    Smyth, Steven
    Christian-Albrechts-Universität zu Kiel.
    von Hanxleden, Reinhard
    Christian-Albrechts-Universität zu Kiel.
    Towards Interactive Timing Analysis for Designing Reactive Systems2014Report (Other academic)
    Abstract [en]

    Reactive systems are increasingly developed using high-level modeling tools. Such modeling tools may facilitate formal reasoning about concurrent programs, but provide little help when timing-related problems arise and deadlines are missed when running a real system. In these cases, the modeler has typically no information about timing properties and costly parts of the model; there is little or no guidance on how to improve the timing characteristics of the model. In this paper, we propose a design methodology where interactive timing analysis is an integral part of the modeling process. This methodology concerns how to aggregate timing values in a user-friendly manner and how to define timing analysis requests. We also introduce and formalize a new timing analysis interface that is designed for communicating timing information between a high-level modeling tool and a lower-level timing analysis tool.

  • 41.
    Fuhrmann, Insa
    et al.
    Kiel University.
    Broman, David
    KTH, School of Information and Communication Technology (ICT), Software and Computer systems, SCS.
    von Hanxleden, Reinhard
    Kiel University.
    Schulz-Rosengarten, Alexander
    Kiel University.
    Time for Reactive System Modeling: Interactive Timing Analysis with Hotspot Highlighting2016In: In Proceedings of the 24th International Conference on Real-Time Networks and Systems (RTNS 2016), ACM Press, 2016Conference paper (Refereed)
    Abstract [en]

    Modeling tools typically provide no information about timing properties and costly parts of the system under development. In this paper we propose a generic approach to integrate timing analysis and modeling tools. This approach includes visual highlighting to guide the user to worst-case execution time hotspots, detailed timing information for specific model elements, and the separation of di↵erent types of timing val- ues. Our solution includes both a way to keep track of model elements subject to timing analysis during the compilation process, and a flexible and formally defined timing analysis interface for communicating timing information between a high-level modeling tool and a lower-level timing analysis tool. We present a complete open-source, Eclipse-based pro- totype tool chain that is evaluated both using a systematic benchmark suite and a user study. 

  • 42. Gomes, Claudio
    et al.
    Thule, Casper
    Broman, David
    KTH, School of Electrical Engineering and Computer Science (EECS), Software and Computer systems, SCS.
    Larsen, Peter Gorm
    Vangheluwe, Hans
    Co-Simulation: A Survey2018In: ACM Computing Surveys, ISSN 0360-0300, E-ISSN 1557-7341, Vol. 51, no 3, article id 49Article in journal (Refereed)
    Abstract [en]

    Modeling and simulation techniques are today extensively used both in industry and science. Parts of larger systems are, however, typically modeled and simulated by different techniques, tools, and algorithms. In addition, experts from different disciplines use various modeling and simulation techniques. Both these facts make it difficult to study coupled heterogeneous systems. Co-simulation is an emerging enabling technique, where global simulation of a coupled system can be achieved by composing the simulations of its parts. Due to its potential and interdisciplinary nature, cosimulation is being studied in different disciplines but with limited sharing of findings. In this survey, we study and survey the state-of-the-art techniques for co-simulation, with the goal of enhancing future research and highlighting the main challenges. To study this broad topic, we start by focusing on discrete-event-based co-simulation, followed by continuous-time-based co-simulation. Finally, we explore the interactions between these two paradigms, in hybrid co-simulation. To survey the current techniques, tools, and research challenges, we systematically classify recently published research literature on co-simulation, and summarize it into a taxonomy. As a result, we identify the need for finding generic approaches for modular, stable, and accurate coupling of simulation units, as well as expressing the adaptations required to ensure that the coupling is correct.

  • 43.
    Isaac, Liu
    et al.
    University of California, Berkeley, USA.
    Reineke, Jan
    Saarland University, Saarbrücken, Germany.
    Broman, David
    Linköpings universitet, PELAB - Laboratoriet för programmeringsomgivningar.
    Zimmer, Michael
    University of California, Berkeley, USA.
    Lee, Edward
    University of California, Berkeley, USA.
    A PRET microarchitecture implementation with repeatable timing and competitive performance2012In: Proceedings of the 30th IEEE International Conference on Computer Design (ICCD 2012), IEEE conference proceedings, 2012, p. 87-93Conference paper (Refereed)
    Abstract [en]

    We contend that repeatability of execution times is crucial to the validity of testing of real-time systems. However, computer architecture designs fail to deliver repeatable timing, a consequence of aggressive techniques that improve average-case performance. This paper introduces the Precision-Timed ARM (PTARM), a precision-timed (PRET) microarchitecture implementation that exhibits repeatable execution times without sacrificing performance. The PTARM employs a repeatable thread-interleaved pipeline with an exposed memory hierarchy, including a repeatable DRAM controller. Our benchmarks show an improved throughput compared to a single-threaded in-order five-stage pipeline, given sufficient parallelism in the software.

  • 44.
    Jonsson, Leif
    et al.
    Eriksson AB and Linköping University.
    Borg, Markus
    Lund University.
    Broman, David
    KTH, School of Information and Communication Technology (ICT), Software and Computer systems, SCS. UC Berkeley, Berkeley, CA, United States.
    Sandahl, Kristian
    Linköping University.
    Eldh, Sigrid
    Ericsson AB.
    Runeson, Per
    Lund University.
    Automated bug assignment: Ensemble-based machine learning in large scale industrial contexts2016In: Journal of Empirical Software Engineering, ISSN 1382-3256, E-ISSN 1573-7616, Vol. 21, no 4, p. 1533-1578Article in journal (Refereed)
    Abstract [en]

    Bug report assignment is an important part of software maintenance. In particular, incorrect assignments of bug reports to development teams can be very expensive in large software development projects. Several studies propose automating bug assignment techniques using machine learning in open source software contexts, but no study exists for large-scale proprietary projects in industry. The goal of this study is to evaluate automated bug assignment techniques that are based on machine learning classification. In particular, we study the state-of-the-art ensemble learner Stacked Generalization (SG) that combines several classifiers. We collect more than 50,000 bug reports from five development projects from two companies in different domains. We implement automated bug assignment and evaluate the performance in a set of controlled experiments. We show that SG scales to large scale industrial application and that it outperforms the use of individual classifiers for bug assignment, reaching prediction accuracies from 50 % to 89 % when large training sets are used. In addition, we show how old training data can decrease the prediction accuracy of bug assignment. We advice industry to use SG for bug assignment in proprietary contexts, using at least 2,000 bug reports for training. Finally, we highlight the importance of not solely relying on results from cross-validation when evaluating automated bug assignment.

  • 45.
    Jonsson, Leif
    et al.
    Ericsson AB, Stockholm, Sweden.
    Broman, David
    Linköpings universitet, PELAB - Laboratoriet för programmeringsomgivningar, Sweden.
    Sandahl, Kristian
    Linköpings universitet, PELAB - Laboratoriet för programmeringsomgivningar, Sweden.
    Eldh, Sigrid
    Ericsson AB, Stockholm, Sweden.
    Towards Automated Anomaly Report Assignment in Large Complex Systems using Stacked Generalization2012In: Proceedings of the Fifth International Conference on Software Testing, Verification and Validation (ICST 2012), IEEE , 2012, p. 437-446Conference paper (Refereed)
    Abstract [en]

    Maintenance costs can be substantial for organizations with very large and complex software systems. This paper describes research for reducing anomaly report turnaround time which, if successful, would contribute to reducing maintenance costs and at the same time maintaining a good customer perception. Specifically, we are addressing the problem of the manual, laborious, and inaccurate process of assigning anomaly reports to the correct design teams. In large organizations with complex systems this is particularly problematic because the receiver of the anomaly report from customer may not have detailed knowledge of the whole system. As a consequence, anomaly reports may be wrongly routed around in the organization causing delays and unnecessary work. We have developed and validated machine learning approach, based on stacked generalization, to automatically route anomaly reports to the correct design teams in the organization. A research prototype has been implemented and evaluated on roughly one year of real anomaly reports on a large and complex system at Ericsson AB. The prediction accuracy of the automation is approaching that of humans, indicating that the anomaly report handling time could be significantly reduced by using our approach.

  • 46. Kim, H.
    et al.
    Broman, David
    KTH, School of Information and Communication Technology (ICT), Software and Computer systems, SCS.
    Kang, E.
    Lee, E. A.
    An Architectural Mechanism for Resilient IoT Services2017In: SafeThings 2017 - Proceedings of the 1st ACM International Workshop on the Internet of Safe Things, Part of SenSys 2017, Association for Computing Machinery (ACM), 2017, p. 8-13Conference paper (Refereed)
    Abstract [en]

    Availability of authentication and authorization services is critical for the safety of the Internet of Things (IoT). By leveraging an emerging network architecture based on edge computers, IoT’s availability can be protected even under situations such as network failures or denial-of-service (DoS) attacks. However, little has been explored for the issue of sustaining availability even when edge computers fail. In this paper, we propose an architectural mechanism for enhancing the availability of the authorization infrastructure for the IoT. The proposed approach leverages a technique called secure migration, which allows IoT devices to migrate to other local authorization entities served in trusted edge computers when their authorization entity becomes unavailable. Specifically, we point out necessary considerations for planning secure migration and present automated migration policy construction and protocols for preparing and executing the migration. The effectiveness of our approach is illustrated using a concrete application of smart buildings and network simulation, where our proposed solution achieves significantly higher availability in case of failures in some of the authorization entities.

  • 47.
    Kim, Hokeun
    et al.
    University of California, Berkeley.
    Broman, David
    KTH, School of Information and Communication Technology (ICT), Software and Computer systems, SCS. University of California, Berkeley.
    Lee, Edward A,
    University of California, Berkeley.
    Zimmer, Michael
    University of California, Berkeley.
    Shrivastava, Aviral
    Arizona State University.
    Oh, Junkwang
    University of California, Berkeley.
    A Predictable and Command- Level Priority-Based DRAM Controller for Mixed-Criticality Systems2015In: Proceedings of the 21th IEEE Real-Time and Embedded Technology and Applications Symposium (RTAS), IEEE Press, 2015, p. 317-326Conference paper (Refereed)
    Abstract [en]

    Mixed-criticality systems have tasks with different criticality levels running on the same hardware platform. Today's DRAM controllers cannot adequately satisfy the often conflicting requirements of tightly bounded worst-case latency for critical tasks and high performance for non-critical real-time tasks. We propose a DRAM memory controller that meets these requirements by using bank-aware address mapping and DRAM command-level priority-based scheduling with preemption. Many standard DRAM controllers can be extended with our approach, incurring no performance penalty when critical tasks are not generating DRAM requests. Our approach is evaluated by replaying memory traces obtained from executing benchmarks on an ARM ISA-based processor with caches, which is simulated on the gem5 architecture simulator. We compare our approach against previous TDM-based approaches, showing that our proposed memory controller achieves dramatically higher performance for non-critical tasks, without any significant impact on the worstcase latency of critical tasks.

  • 48.
    Kim, Hokeun
    et al.
    University of California, Berkeley.
    Kang, Eunsuk
    University of California, Berkeley.
    Edward, Lee
    University of California, Berkeley.
    Broman, David
    KTH, School of Information and Communication Technology (ICT), Software and Computer systems, SCS.
    A Toolkit for Construction of Authorization Service Infrastructure for the Internet of Things2017In: Internet-of-Things Design and Implementation (IoTDI), 2017 IEEE/ACM Second International Conference on, ACM Digital Library, 2017, p. 147-158Conference paper (Refereed)
    Abstract [en]

    The challenges posed by the Internet of Things (IoT) render existing security measures ineffective against emerging networks and devices. These challenges include heterogeneity, operation in open environments, and scalability. In this paper, we propose SST (Secure Swarm Toolkit), an open-source toolkit for construction and deployment of an authorization service infrastructure for the IoT. The infrastructure uses distributed local authorization entities, which provide authorization services that can address heterogeneous security requirements and resource constraints in the IoT. The authorization services can be accessed by network entities through software interfaces provided by SST, called accessors. The accessors enable IoT developers to readily integrate their devices with authorization services without needing to manage cryptographic keys and operations. To rigorously show that SST provides necessary security guarantees, we have performed a formal security analysis using an automated verification tool. In addition, we demonstrate the scalability of our approach with a mathematical analysis, as well as experiments to evaluate security overhead of network entities under different security profiles supported by SST

  • 49. Kim, Y.
    et al.
    Broman, David
    KTH, School of Information and Communication Technology (ICT), Software and Computer systems, SCS.
    Shrivastava, A.
    Wcet-aware function-level dynamic code management on Scratchpad memory2017In: ACM Transactions on Embedded Computing Systems, ISSN 1539-9087, E-ISSN 1558-3465, Vol. 16, no 4, article id 112Article in journal (Refereed)
    Abstract [en]

    Scratchpad memory (SPM) is a promising on-chip memory choice in real-time and cyber-physical systems where timing is of the utmost importance. SPM has time-predictable characteristics since its data movement between the SPM and the main memory is entirely managed by software. One way of such management is dynamic management. In dynamic management of instruction SPMs, code blocks are dynamically copied from the main memory to the SPM at runtime by executing direct memory access (DMA) instructions. Code management techniques try to minimize the overhead of DMA operations by finding an allocation scheme that leads to efficient utilization. In this article, we present three function-level code management techniques. These techniques perform allocation at the granularity of functions, with the objective of minimizing the impact of DMA overhead to the worst-case execution time (WCET) of a given program. The first technique finds an optimal mapping of each function to a region using integer linear programming (ILP), whereas the second technique is a polynomial-time heuristic that is suboptimal. The third technique maps functions directly to SPM addresses, not using regions, which can further reduce the WCET. Based on ILP, it can also find an optimal mapping. We evaluate our techniques using the Mälardalen WCET suite, MiBench suite, and proprietary automotive applications from industry. The results show that our techniques can significantly reduce the WCET estimates compared to caches with the state-of-the-art cache analysis.

  • 50.
    Kim, Yooseong
    et al.
    University of California, Berkeley and Arizona State University.
    Broman, David
    University of California, Berkeley and Linkoping University.
    Cai, Jian
    Arizona State University.
    Shrivastaval, Aviral
    University of California, Berkeley and Arizona State University.
    WCET-Aware Dynamic Code Management on Scratchpads for Software-Managed Multicores2014In: Proceedings of the 20th IEEE Real-Time and Embedded Technology and Application Symposium (RTAS 2014), IEEE conference proceedings, 2014, p. 179-188Conference paper (Refereed)
    Abstract [en]

    Software Managed Multicore (SMM) architectures have advantageous scalability, power efficiency, and predictability characteristics, making SMM particularly promising for real-time systems. In SMM architectures, each core can only access its scratchpad memory (SPM); any access to main memory is done explicitly by DMA instructions. As a consequence, dynamic code management techniques are essential for loading program code from the main memory to SPM. Current state-of-the-art dynamic code management techniques for SMM architectures are, however, optimized for average-case execution time, not worst-case execution time (WCET), which is vital for hard real-time systems. In this paper, we present two novel WCET-aware dynamic SPM code management techniques for SMM architectures. The first technique is optimal and based on integer linear programming (ILP), whereas the second technique is a heuristic that is suboptimal, but scalable. Experimental results with benchmarks from Mälardalen WCET suite and MiBench suite show that our ILP solution can reduce the WCET estimates up to 80% compared to previous techniques. Furthermore, our heuristic can, for most benchmarks, find the same optimal mappings within one second on a 2GHz dual core machine.

12 1 - 50 of 61
CiteExportLink to result list
Permanent link
Cite
Citation style
  • apa
  • harvard1
  • ieee
  • modern-language-association-8th-edition
  • vancouver
  • Other style
More styles
Language
  • de-DE
  • en-GB
  • en-US
  • fi-FI
  • nn-NO
  • nn-NB
  • sv-SE
  • Other locale
More languages
Output format
  • html
  • text
  • asciidoc
  • rtf