Time-triggered buffers for event-based middleware systems

Jonathan Sprinkle, Brandon Eames

Research output: Contribution to journalArticle

3 Citations (Scopus)

Abstract

Application developers utilizing event-based middleware have sought to leverage domain-specific modeling for the advantages of intuitive specification, code synthesis, and support for design evolution. For legacy and cysber-physical systems, the use of event-based middleware may mean that changes in computational platform can result anomalous system behavior, due to the presence of implicit temporal dependencies. These anomalies are a function not of the component implementation, but of the model of computation employed for supporting system composition. In order to address these behavioral anomalies, the paper presents an approach where time-based blocks are inserted into the system to account for the temporal dependencies. An advantage of capturing the system composition in a domain-specific modeling language is the ability to efficiently re factor an application to include time-triggered, event-based schedulers. This paper describes how an existing event-based component topology can be modified to permit a time-triggered model of computation, with no changes to the existing component software. Further, the time-triggered components can be deployed alongside standard publish/subscribe methodologies. This strategy is beneficial to the maintenance of existing legacy systems upon upgrade, since the current operational mode could be maintained with minimal changes to the legacy software even under changes to the target platform which alter execution speed. These time-triggered layers are discussed in three permutations: fully triggered, start triggered, and release triggered. A discussion is provided regarding the limitations of each approach, and a brief example is given. The example shows how to apply these triggering approaches without the modification of existing components, but instead through the insertion of triggered buffers between legacy components.

Original languageEnglish (US)
Pages (from-to)9-22
Number of pages14
JournalInnovations in Systems and Software Engineering
Volume7
Issue number1
DOIs
StatePublished - Jan 2011

Fingerprint

Middleware
Computer systems
Legacy systems
Chemical analysis
Topology
Specifications
Modeling languages

Keywords

  • Distributed real-time systems
  • Embedded systems
  • Giotto
  • Logical execution time
  • Model transformations

ASJC Scopus subject areas

  • Software

Cite this

Time-triggered buffers for event-based middleware systems. / Sprinkle, Jonathan; Eames, Brandon.

In: Innovations in Systems and Software Engineering, Vol. 7, No. 1, 01.2011, p. 9-22.

Research output: Contribution to journalArticle

@article{60937460c44e4f9688456f8cbe277a1f,
title = "Time-triggered buffers for event-based middleware systems",
abstract = "Application developers utilizing event-based middleware have sought to leverage domain-specific modeling for the advantages of intuitive specification, code synthesis, and support for design evolution. For legacy and cysber-physical systems, the use of event-based middleware may mean that changes in computational platform can result anomalous system behavior, due to the presence of implicit temporal dependencies. These anomalies are a function not of the component implementation, but of the model of computation employed for supporting system composition. In order to address these behavioral anomalies, the paper presents an approach where time-based blocks are inserted into the system to account for the temporal dependencies. An advantage of capturing the system composition in a domain-specific modeling language is the ability to efficiently re factor an application to include time-triggered, event-based schedulers. This paper describes how an existing event-based component topology can be modified to permit a time-triggered model of computation, with no changes to the existing component software. Further, the time-triggered components can be deployed alongside standard publish/subscribe methodologies. This strategy is beneficial to the maintenance of existing legacy systems upon upgrade, since the current operational mode could be maintained with minimal changes to the legacy software even under changes to the target platform which alter execution speed. These time-triggered layers are discussed in three permutations: fully triggered, start triggered, and release triggered. A discussion is provided regarding the limitations of each approach, and a brief example is given. The example shows how to apply these triggering approaches without the modification of existing components, but instead through the insertion of triggered buffers between legacy components.",
keywords = "Distributed real-time systems, Embedded systems, Giotto, Logical execution time, Model transformations",
author = "Jonathan Sprinkle and Brandon Eames",
year = "2011",
month = "1",
doi = "10.1007/s11334-010-0139-7",
language = "English (US)",
volume = "7",
pages = "9--22",
journal = "Innovations in Systems and Software Engineering",
issn = "1614-5046",
publisher = "Springer London",
number = "1",

}

TY - JOUR

T1 - Time-triggered buffers for event-based middleware systems

AU - Sprinkle, Jonathan

AU - Eames, Brandon

PY - 2011/1

Y1 - 2011/1

N2 - Application developers utilizing event-based middleware have sought to leverage domain-specific modeling for the advantages of intuitive specification, code synthesis, and support for design evolution. For legacy and cysber-physical systems, the use of event-based middleware may mean that changes in computational platform can result anomalous system behavior, due to the presence of implicit temporal dependencies. These anomalies are a function not of the component implementation, but of the model of computation employed for supporting system composition. In order to address these behavioral anomalies, the paper presents an approach where time-based blocks are inserted into the system to account for the temporal dependencies. An advantage of capturing the system composition in a domain-specific modeling language is the ability to efficiently re factor an application to include time-triggered, event-based schedulers. This paper describes how an existing event-based component topology can be modified to permit a time-triggered model of computation, with no changes to the existing component software. Further, the time-triggered components can be deployed alongside standard publish/subscribe methodologies. This strategy is beneficial to the maintenance of existing legacy systems upon upgrade, since the current operational mode could be maintained with minimal changes to the legacy software even under changes to the target platform which alter execution speed. These time-triggered layers are discussed in three permutations: fully triggered, start triggered, and release triggered. A discussion is provided regarding the limitations of each approach, and a brief example is given. The example shows how to apply these triggering approaches without the modification of existing components, but instead through the insertion of triggered buffers between legacy components.

AB - Application developers utilizing event-based middleware have sought to leverage domain-specific modeling for the advantages of intuitive specification, code synthesis, and support for design evolution. For legacy and cysber-physical systems, the use of event-based middleware may mean that changes in computational platform can result anomalous system behavior, due to the presence of implicit temporal dependencies. These anomalies are a function not of the component implementation, but of the model of computation employed for supporting system composition. In order to address these behavioral anomalies, the paper presents an approach where time-based blocks are inserted into the system to account for the temporal dependencies. An advantage of capturing the system composition in a domain-specific modeling language is the ability to efficiently re factor an application to include time-triggered, event-based schedulers. This paper describes how an existing event-based component topology can be modified to permit a time-triggered model of computation, with no changes to the existing component software. Further, the time-triggered components can be deployed alongside standard publish/subscribe methodologies. This strategy is beneficial to the maintenance of existing legacy systems upon upgrade, since the current operational mode could be maintained with minimal changes to the legacy software even under changes to the target platform which alter execution speed. These time-triggered layers are discussed in three permutations: fully triggered, start triggered, and release triggered. A discussion is provided regarding the limitations of each approach, and a brief example is given. The example shows how to apply these triggering approaches without the modification of existing components, but instead through the insertion of triggered buffers between legacy components.

KW - Distributed real-time systems

KW - Embedded systems

KW - Giotto

KW - Logical execution time

KW - Model transformations

UR - http://www.scopus.com/inward/record.url?scp=79952247440&partnerID=8YFLogxK

UR - http://www.scopus.com/inward/citedby.url?scp=79952247440&partnerID=8YFLogxK

U2 - 10.1007/s11334-010-0139-7

DO - 10.1007/s11334-010-0139-7

M3 - Article

AN - SCOPUS:79952247440

VL - 7

SP - 9

EP - 22

JO - Innovations in Systems and Software Engineering

JF - Innovations in Systems and Software Engineering

SN - 1614-5046

IS - 1

ER -