An Execution Model for Fine-Grained Parallelism in Ada

Abstract

Abstract. 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.

Real-Time Fine-Grained Parallelism in Ada

“…The default model of tasklet execution by the executors is a limited form of run-to-completion, i.e., when a tasklet starts to be executed by one executor, it is executed by this same executor until the tasklet finishes. Limited because, under certain conditions (see [4]) tasklets are allowed to be executed by more than one executor. Note that at any time the executor itself might be preempted by another executor executing a higher-priority tasklet.…”

“…In [4] we identify the conditions in which tasklets may synchronize with protected operations (tasklets are the "caller" as specified in the standard [5, section 9.5]):…”

“…5 Real-time model [4] proposes a model of real-time parallel programming where real-time tasks map one-to-one with Ada tasks. The execution of the Ada task generates a (potentially recurrent) DAG of tasklets (varying because of control-flow), running on a shared memory multiprocessor (multi/manycore).…”

“…The current proposal to extend Ada with a fine-grained parallelism model [1,2,3,4] is based on the notion of tasklets, which are non-schedulable computation units (similar to Cilk [6] or OpenMP [7] tasks).…”

“…The model also specifies that calls by different tasklets of the same task into the same protected object are treated as different calls resulting in distinct protected actions; therefore synchronization between tasklets could be performed using protected operations (though in [3] this was restricted to non-blocking operations). 2 In [4], the model was extended with a proposal for the underlying tasklet execution behavior, based on the notion of abstract executors, which carry the actual execution of Ada tasks in the platform. The goal of this abstraction is to to provide the ability to specify the progress guarantees that an implementation (compiler and runtime) need to provide to the parallel execution, without constraining how such implementation should be done.…”