The first session of the 18th International Real Time Ada Workshop discussed two aspects of parallel programming in real-time systems, the use of executors in parallel systems, and syntax to guide the reduction of parallel computations to return a correct single answer. This report captures the discussions held and the decisions and recommendations of the workshop on these topics.

ISO IEC JTC 1 SC 22 WG 23 Vulnerabilities Working Group is documenting new vulnerabilities in preparation for the release of TR 24772 edition 3. An identified area is in the accounting and management of time in normal systems and real-time systems. Various vulnerabilities related to time are documented, as well as avoidance and mitigations of the issues raised.

The first session of the 18th International Real Time Ada Workshop discussed two aspects of parallel programming in real-time systems, the use of executors in parallel systems, and syntax to guide the reduction of parallel computations to return a correct single answer. This report captures the discussions held and the decisions and recommendations of the workshop on these topics.

Previous work proposed the inclusion of parallelism in Ada to improve the use of multicore processors. This work proposed a model of Tasklets to carry the expressions of parallelism, and introduced the notion of executors to map the execution of Tasklets on hardware. In developing the model, a number of choices arise that effect how well the model will accommodate real-time systems. These choices become constraints which are examined and reasonable choices proposed for adoption in Ada.

One of the most common program constructs to be parallelized (and where most of the times gains are obtained) is parallel loops. This paper discusses different approaches to support loop parallelization in the fine-grained parallelism model for Ada currently being proposed, focusing in particular in the issues related to reducing operations.

The approach for fine-grained parallelism in Ada presented at the last Real-Time Ada Workshop has been revised, both in terms of the language mechanisms to specify parallelism, as well as in terms of the underlying execution model. This paper summarizes the current state of the proposal, further detailing how programmers can control the behavior of the parallel execution, and discussing the issues which are still open.

This paper extends the authors earlier proposal for providing Ada with support for fine-grained parallelism with an execution model based on the concept of abstract executors, detailing the progress guarantees that these executors must provide and how these can be assured even in the presence of potentially blocking operations. The paper also describes how this execution model can be applied to real-time systems.

review-article Share on Session Summary: Fine-grained parallelism Reviewer: Brad Moore View Profile , Staffs: Luis Miguel Pinho View Profile , Stephen Michell View Profile Authors Info & Claims ACM SIGAda Ada LettersVolume 35Issue 1April 2015 pp 97–101https://doi.org/10.1145/2870544.2870557Published:28 December 2015Publication History 1citation25DownloadsMetricsTotal Citations1Total Downloads25Last 12 Months0Last 6 weeks0 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteGet Access

The Ada language has for long provided support for the development of reliable real-time systems, with a model of computation amenable for real-time analysis. To complement the already existent multiprocessor support in the language, an ongoing effort is underway to extend Ada with a fine-grained parallel programming model also suitable for real-time systems. This paper overviews the model which is being proposed, pointing out the main issues still open and road ahead.

The increased presence of parallel computing platforms brings concerns to the general purpose domain that were previously prevalent only in the specific niche of high-performance computing. As parallel programming technologies become more prevalent in the form of new emerging programming languages and extensions of existing languages, additional safety concerns arise as part of the paradigm shift from sequential to parallel behaviour. In this paper, we propose various syntax extensions to the Ada language, which provide mechanisms whereby the compiler is given the necessary semantic information to enable the implicit and explicit parallelization of code. The model is based on earlier work, which separates parallelism specification from concurrency implementation, but proposes an updated syntax with additional mechanisms to facilitate the development of safer parallel programs.

Recently, a semantic and runtime model for parallel programming was proposed for addition to Ada. The proposal uses program annotations (expressed as Ada 2012 aspects) to inform the compiler of opportunities for parallel computation, and also offers the ability to specify details of parallel execution. The proposal includes support for specialized behaviors via dedicated libraries and a runtime environment that builds on pools of worker tasks. This paper extends that work by adding notations for data types and parallel blocks, simplifying some of the parallel notations and eliminating obstructions to the implementation of efficient parallel algorithms.

Parallel programming is expected to become more the norm as multi-core and many-core processors gain more widespread use. Ada has always had excellent concurrency support, but could be improved in the area of parallel programming. Specifically, divide and conquer parallelism via parallel loops and subprograms are difficult to write without some sort of library support. In this paper we describe a proposal that combines the use of task pools and parallelism managers to provide parallelism capabilities to real-time Ada applications, including Ravenscar applications. This work complements the syntax enhancements that we previously proposed, so that together they facilitate the writing of parallel applications.

Multi-core platforms are challenging the way software is developed, in all application domains. For the particular case of real-time systems, models for the development of parallel software must be able to be shown correct in both functional and non-functional properties at design-time. In particular, issues such as concurrency, timing behaviour and interaction with the environment need to be addressed with the same caution as for the functional requirements. This paper proposes an execution model for the parallelization of real-time software, based upon a fine-grained parallelism support being proposed to Ada, a programming language particularly suited to the development of critical, concurrent software. We also show the correctness of the proposed model in terms of satisfying constraints related to execution order and unbounded priority inversions.

The widespread use of multi-CPU computers is challenging programming languages, which need to adapt to be able to express potential parallelism at the language level. In this paper we propose a new model for fine grained parallelism in Ada, putting forward a syntax based on aspects, and the corresponding semantics to integrate this model with the existing Ada tasking capabilities. We also propose a standard interface and show how it can be extended by the user or library writers to implement their own parallelization strategies.

Parallel programming is expected to become more the norm as multi-core and many-core processors gain more widespread use. Ada has always had excellent concurrency support, but could be improved in the area of parallel programming. Specifically, divide and conquer parallelism via parallel loops and subprograms are difficult to write without some sort of library support. In this paper we describe a proposal that combines the use of task pools and parallelism managers to provide parallelism capabilities to real-time Ada applications, including Ravenscar applications. This work complements the syntax enhancements that we previously proposed, so that together they facilitate the writing of parallel applications.

review-article Share on Session summary: concurrency issues Authors: Juan Antonio de la Puente View Profile , Stephen Michell View Profile Authors Info & Claims ACM SIGAda Ada LettersVolume 33Issue 1April 2013 pp 150–156https://doi.org/10.1145/2492312.2492330Online:11 June 2013Publication History 1citation68DownloadsMetricsTotal Citations1Total Downloads68Last 12 Months4Last 6 weeks0 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteGet Access

The vulnerability methodology of the ISO/IEC/JTC 1/ SC 22/ WG 23 Programming Language Vulnerabilities Working Group is applied to the problem space of concurrency. A set of vulnerabilities is developed to capture the issues thread creation, thread termination, shared data access, resource hijacking and communication protocols.