Weiter: 9.8 Scheduling von Hinauf: 9 Tasks Zurück: 9.6 Familien von

9.7 Diskriminierte Tasks

Task-Typen können auch eine Diskriminante besitzen. Typische Anwendungen sind zum Beispiel

ein Semaphor, wobei mehrere Tasks parallel auf die Ressource zugreifen können (die Anzahl der möglichen parallelen Zugriffe wird als Wert der Diskriminante beim Anlegen des Task-Objektes übergeben) und
Setzen der Priorität oder des maximalen Speicherbedarfs eines Tasks mit den passenden Pragmas priority und storage_size.

Diskriminanten können aber auch verwendet werden, um Tasks eine Art von Identifikation zu geben. Betrachten wir folgendes Beispiel:

subtype Task_Range is 1 .. 1000;

function Next_One return Task_Range;

task type Computer(Index: Task_Range := Next_One);

The_Tasks: array (Task_Range) of Computer;

Die Funktion Next_One liefert einen Wert der Task_Range nach dem anderen. Es ist zwar nicht gewährleistet, daß die ID eines Tasks mit dem Index im array übereinstimmt, aber da die Tasks nicht parallel gestartet werden, brauchen wir uns keinerlei Synchronisationsmechanismen im Zusammenhang mit der Funktion Next_One überlegen.

Ein anderes Beispiel, wie diskriminierte Tasks und Typerweiterung zusammenarbeiten können, sei wie folgt gegeben:

task type T(Job: access Job_Descriptor'CLASS);

task body T is
begin
Start(Job);
for I in 1 .. Iterations(Job) loop
delay Interval(Job);
Do_It(Job, I);
end loop;
Finish(Job);
exception
when Event: others = $>$
Handle_Failure(Job, Event);
end T;

Da die Diskriminante ein klassenweiter Typ ist, kann der Dispatching-Mechanismus voll greifen. Das heißt, die Unterprogramme Start, Iterations, Interval, Do_It, Finish und Handle_Failure sind alle Operationen des Typs Job_Descriptor und könnten wie folgt aussehen:

package Base_Job is
type Job_Descriptor is abstract tagged null record;
procedure Start(J: access Job_Descriptor);
function Iterations(J: access Job_Descriptor) return integer is abstract;
function Interval(J: access Job_Descriptor) return duration is abstract;
procedure Do_It(J: access Job_Descriptor; I: integer) is abstract;
procedure Finish(J: access Job_Descriptor);
procedure Handle_Failure(J: access Job_Descriptor; E: Exception_Occurence);
end Base_Job;

Die meisten Unterprogramme sind abstrakt, um den Benutzer zu zwingen, seine eigenen Implementierungen zu schaffen. Nur Start und Finish haben als Default Null-Operationen, da das sinnvoll erscheint. Handle_Failure sollte ebenfalls eine sinnvolle Default-Operation besitzen.

Eine sinnvolle Implementierung eines Jobs ist dem Leser überlassen.

Weiter: 9.8 Scheduling von Hinauf: 9 Tasks Zurück: 9.6 Familien von

Johann Blieberger
Wed Feb 11 09:58:52 MET 1998