tasking: advanced examples

Author: leogermond

courses/fundamentals_of_ada/240_tasking/05-task_types_in_depth.rst

@@ -158,6 +158,40 @@ Protected Object Entries
       ...
    end Object;
 
+-------------------------------------
+Discriminated Protected or Task types
+-------------------------------------
+
+* Discriminant can be an :ada:`access` or discrete type
+* Resulting type is indefinite
+
+    - Unless mutable
+
+* Example: counter shared between tasks
+
+.. code:: Ada
+
+   protected type Counter_T is
+      procedure Increment;
+   end Counter_T
+
+   task type My_Task (Counter : not null access Counter_T) is [...]
+
+   task body My_Task is
+   begin
+      Counter.Increment;
+      [...]
+
+----------------------------------------
+Using discriminant for Real-Time aspects
+----------------------------------------
+
+.. code:: Ada
+
+   protected type Protected_With_Priority (Prio : System.Priority)
+      with Priority => Prio
+   is
+
 ------------------------------------------
 Example: Protected Objects - Declaration
 ------------------------------------------

courses/fundamentals_of_ada/240_tasking/22-task_safe_interfaces.rst

@@ -0,0 +1,147 @@
+====================
+Task Safe Interfaces
+====================
+
+-----------------
+Problem Statement
+-----------------
+
+* Designing task-safe code requires using dedicated constructs
+* How to reuse the components?
+* How to refactor task-unsafe code into task-safe version?
+
+----------------
+Access Protected
+----------------
+
+* Access to :ada:`protected` objects' subprograms
+* :ada:`type P is access protected procedure (args...)`
+* :ada:`type F is access protected function (args...) return ...`
+
+.. code:: Ada
+
+   type Work_Id is tagged limited private;
+
+   type Work_Handler is
+      access protected procedure (T : Work_Id);
+
+----------------------
+Synchronized Interface
+----------------------
+
+* :ada:`synchronized interface` can be inherited by :ada:`task`/:ada:`protected` types
+
+.. code:: Ada
+
+   type Counter_I is synchronized interface;
+   procedure Increment (Counter : in out Counter_I) is abstract;
+
+   task type Counter_Task_T is new Counter_I with
+      -- Always implemented as an entry for tasks
+      entry Increment;
+   end task;
+
+   protected type Counter_Prot_T is new Counter_I with
+      procedure Increment;
+   end Counter_Prot_T;
+
+* Also present:
+
+  - :ada:`task interface` meant for tasks only
+  - :ada:`protected interface` meant for protected types only
+
+.. warning::
+
+    Only available in **full-tasking** runtimes
+
+---------------------------------
+Standard Library Queues Interface
+---------------------------------
+
+* In :ada:`Ada.Containers`
+* :ada:`Synchronized_Queue_Interfaces` interface
+
+.. tip::
+
+    Provides a portable interface
+
+.. code:: Ada
+
+    generic
+       type Element_Type is private;
+    package Ada.Containers.Synchronized_Queue_Interfaces is
+       type Queue is synchronized interface;
+
+---------------------------------------
+Standard Library Queues Implementations
+---------------------------------------
+
+* Four implementations
+
+.. tip::
+
+    Better than rolling-out one's own queue implementation
+
+* Synchronized implementations
+
+    - :ada:`Unbounded_Synchronized_Queues`
+    - :ada:`Bounded_Synchronized_Queues`
+    - As :ada:`protected` types
+    - With priority ceiling
+
+* Priority implementations
+
+    - :ada:`Unbounded_Priority_Queues`
+    - :ada:`Bounded_Priotiry_Queues`
+    - As :ada:`protected` types
+    - Elements provide :ada:`Get_Priority`
+
+        + Used for sorting elements
+
+----------------------------
+Example: Scheduler Interface
+----------------------------
+
+.. code:: Ada
+
+   type Scheduler_I;
+   type Maybe_Work_Item_I is access protected procedure;
+   type Work_Item_I is not null access protected procedure;
+
+   type Scheduler_I is synchronized interface;
+   procedure Queue (S : in out Scheduler_I; W : Work_Item_I) is abstract;
+   procedure Execute_Next (S : in out Scheduler_I) is abstract;
+
+   type Work_Items_Array is array (Positive range <>)
+     of Maybe_Work_Item_I;
+
+   protected type Scheduler_T (Size : Positive) is new Scheduler_I with
+      procedure Queue (W : Work_Item_I);
+      entry Execute_Next;
+   private
+      Number_Of_Items : Natural := 0;
+      Items : Work_Items_Array (1 .. Size);
+   end Scheduler_T;
+
+-------------------------
+Example: Scheduler (Body)
+-------------------------
+
+.. code:: Ada
+
+   protected body Scheduler_T is
+      procedure Queue (W : Work_Item_I) is
+      begin
+         Number_Of_Items := Number_Of_Items + 1;
+         Items (Number_Of_Items) := Maybe_Work_Item_I (W);
+      end Queue;
+
+      entry Execute_Next
+         when Number_Of_Items > 0
+      is
+         W : Work_Item_I := Work_Item_I (Items (Number_Of_Items));
+      begin
+         Number_Of_Items := Number_Of_Items - 1;
+         W.all;
+      end Execute_Next;
+   end Scheduler_T;

courses/fundamentals_of_ada/700_expert_resource_management.rst

@@ -40,3 +40,4 @@ Expert Resource Management
 .. include:: 140_access_types/11-idiom_constant_pointer.rst
 .. include:: 260_controlled_types/10-idiom_refcounting.rst
 .. include:: 240_tasking/21-gnat_semaphores.rst
+.. include:: 240_tasking/22-task_safe_interfaces.rst