Skip to main content
SpringerLink
Log in

Real-time Concurrent C: A language for programming dynamic real-time systems

  • Published:
Real-Time Systems Aims and scope Submit manuscript

Abstract

Concurrent C, is a parallel superset of C (and of C++) that provides facilities such as specifying timeouts during process interactions, delaying program execution, accepting messages in a user-specified order, and asynchronous messages that can be used for writing real-time programs. However, Concurrent C does not provide facilities for specifying strict timing constraints, e.g., Concurrent C only ensures that the lower bounds on the specified delay and timeout periods are satisfied.

Real-Time Concurrent C extends Concurrent C by providing facilities to specify periodicity or deadline constraints, to seek guarantees that timing constraints will be met, and to perform alternative actions when either the timing constraints cannot be met or the guarantees are not available.

In this paper, we will discuss requirements for a real-time programming language, briefly summarize Concurrent C, and motivate and describe the real-time extensions to Concurrent C. We also discuss scheduling and other run-time facilities that have been incorporated to support the real-time extensions. A prototype implementation of Real-Time Concurrent C is nearing completion.

This is a preview of subscription content, log in via an institution to check access.

Access this article

Log in via an institution

Price excludes VAT (USA)
Tax calculation will be finalised during checkout.

Instant access to the full article PDF.

Institutional subscriptions

Similar content being viewed by others

References

  • Baker, T. 1990. The Use of Ada for Real-Time Systems. Real-Time Systems Newletter 6, 1: 3–8.

    Google Scholar 

  • Burns, A. and Wellings, A. 1989. Real-Time Systems and their Programming Languages. Reading, MA: Addison-Wesley.

    Google Scholar 

  • Gehani, N.H. and Roome, W.D. 1986. Concurrent C. Software—Practice & Experience, 16, 9: 821–844.

    Google Scholar 

  • Gehani, N.H. and Roome, W.D. 1989. Concurrent C. Summit, NJ: Silicon Press.

    Google Scholar 

  • Cmelik, R.G., Gehani, N.H., and Roome, W.D. 1988. Fault Tolerant Concurrent C: A Tool for Writing Fault Tolerant Distributed Programs. The 18th International Symposium on Fault-Tolerant Computing, Tokyo, Japan, pp. 56–61.

  • Grimshaw, A.S., Silberman, A., and Liu, J.W.S. 1990. Real-Time Mentat Programming Language and Architecture. Seventh Workshop on Real-Time Operating Systems and Software, pp. 82–87.

  • Halang, W.A. and Stoyenko, A.D. 1990. Comparative Evaluation of High-Level Real-Time Programming Languages. Real-Time Systems 2, 4: 365–382.

    Google Scholar 

  • Ishikawa, Y., Tokuda, H. and Mercer, C.W. 1990. Object-Oriented Real-Time Language Design: Constructs for Timing Constraints. Proceedings of OOPSLA/ECOOP 90, pp. 289–298.

  • Klingerman and Stoyenko. 1986. Real-Time Euclid: A Language for Reliable Real-Time Systems. IEEE Transaction on Software Engineering 12, 9: 941–949.

    Google Scholar 

  • Lavoie, P. 1991. A Tool to Analyze Timing on a 68020 Processor. Master's Project Report, Department of Computer Science, University of Massachusetts, Amherst.

    Google Scholar 

  • Lee, I. and Gehlot, V. 1985. Language Constructs for Distributed Real-Time Programming Systems. Real-Time Systems Symposium.

  • Lehoczky, J.P., Sha, L. and Strosnider, J. 1987. Enhancing Aperiodic Responsiveness in a Hard Real-Time Environment. IEEE Real-Time Systems Symp.

  • Liu, C.L. and Layland, J. 1973. Scheduling Algorithms for Multiprogramming in a Hard Real-Time Environment. J. ACM 20, 1.

    Google Scholar 

  • Marlin, C., Zhao, W., Doherty, G. and Bohonis, A. 1990. GARTL: A Real-Time Programming Language Based on Multi-Version Computation. Proc. International Conference On Computer Languages, pp. 107–115.

  • Pedregal-Martin, C. (forthcoming). A Real-Time Concurrent C Prototype, Master's Project Report, Department of Computer Science, University of Massachusetts, Amherst.

  • Puschner, P. and Koza, Ch. 1989. Calculating Maximum Execution Time of Real-Time Programs. The Journal of Real-Time Systems, pp. 159–176.

  • Mok, A. 1989. Evaluating Tight Execution Time Bounds of Programs by Annotations. Proc. IEEE Workshop on Real-Time Operating Systems and Software, pp. 74–80.

  • Ramamritham, K., Stankovic, J. and Shiah, P. 1990. Efficient Scheduling Algorithms for Real-Time Multiprocessor Systems. IEEE Transactions on Parallel and Distributed Systems, pp. 184–194.

  • Sha, L., Rajkumar, R. and Lehoczky, J.P. 1990. Priority Inheritance Protocols: An Approach to Real-Time Synchronization. IEEE Transactions on Computers.

  • Shaw, A. 1990. Deterministic Timing Schema for Parallel Programs. Technical Report #90-05-06, Department of Computer Science, University of Washington.

  • Stankovic, J.A. and Ramamritham, K. 1991. The Spring Kernel: A New Paradigm for Real-Time Systems. IEEE Software, pp. 62–72.

Download references

Author information

Authors and Affiliations

  1. AT&T Bell Labs, 07974, Murray Hill, NJ, U.S.A.

    Narain Gehani

  2. University of Massachusetts, 01003, Amherst, MA, U.S.A.

    Krithi Ramamritham

Authors
  1. Narain Gehani
    View author publications

    You can also search for this author in PubMed Google Scholar

  2. Krithi Ramamritham
    View author publications

    You can also search for this author in PubMed Google Scholar

Rights and permissions

Reprints and permissions

About this article

Cite this article

Gehani, N., Ramamritham, K. Real-time Concurrent C: A language for programming dynamic real-time systems. The Journal of Real-Time Systems 3, 377–405 (1991). https://doi.org/10.1007/BF00365999

Download citation

  • Issue Date:

  • DOI: https://doi.org/10.1007/BF00365999

Keywords

Search

Navigation