home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / spezial / 03 / rahmen / schedul.pas < prev    next >
Encoding:
Pascal/Delphi Source File  |  1988-09-04  |  9.3 KB  |  244 lines
  1. (**********************************************************)
  2. (*                                                        *)
  3. (*   Filename SCHEDUL.PAS                                 *)
  4. (*                                                        *)
  5. (*   TOOLBOX-Spezial III Echtzeitverarbeitung             *)
  6. (*                                                        *)
  7. (*   (C) TOOLBOX und Thomas Lang 1988                     *)
  8. (*                                                        *)
  9. (*   Dieses File enthält den eigentlichen Scheduler.      *)
  10. (*   Mit ihm werden die anstehenden Aufgaben entspre-     *)
  11. (*   chend ihrer jeweiligen Priorität bearbeitet.         *)
  12. (*   Die notwendigen Deklarationen sind in einem extra    *)
  13. (*   File (SCHEDUL.DCL) vorhanden, das vom Hauptprogramm  *)
  14. (*   vor diesem Scheduler mit der Include Anweisung       *)
  15. (*   eingebunden werden muß. Alle sonst noch notwendigen  *)
  16. (*   Deklarationen von Prozeduren, die der Scheduler      *)
  17. (*   aufruft, müssen ebenfalls vor diesem eingebunden     *)
  18. (*   werden.                                              *)
  19. (*                                                        *)
  20. (**********************************************************)
  21.  
  22. Procedure InitSchedul;        (* Prozedur zur Initiali- *)
  23. Var                           (* sierung des Schedulers *)
  24.    Zaehler:Integer;
  25. Begin
  26.    Ende:=False;               (* Ende nicht erreicht *)
  27.  
  28.    For Zaehler:=1 To AnzahlHoch Do
  29.       Aufgabe.Hoch[Zaehler]:=False;
  30.                               (* keine Aufgabe mit *)
  31.                               (* hoher Priorität *)
  32.  
  33.    For Zaehler:=1 To AnzahlPeriodic Do
  34.       Aufgabe.Periodic[Zaehler].ZuTun:=False;
  35.                               (* keine Aufgabe aus *)
  36.                               (* Periodic steht an *)
  37.  
  38.  
  39.    FifoIndexIn:=1;            (* Fifo initialisieren *)
  40.    FifoIndexOut:=1;           (* also Indizes gleich und *)
  41.    FifoLeer:=True;            (* Fifo ist leer *)
  42.  
  43.    PeriodicIndexOut:=1;       (* bei 1. beginnen *)
  44.  
  45.    HochOverFlow:=0;
  46.    FifoOverFlow:=0;
  47.    PerOverFlow:=0;
  48.  
  49.    BelastungsZaehler.AnteilHoch:=0;
  50.    BelastungsZaehler.AnteilNiedrig:=0;
  51.  
  52. End;                          (* von InitSchedul *)
  53.  
  54. Procedure Schedul;
  55.                               (* lokale Funktionen von *)
  56.                               (* Schedul zur Verzweigung *)
  57.                               (* entsprechend der an- *)
  58.                               (* stehenden Aufgaben *)
  59.  
  60.    Function VerzweigHoch:Boolean;
  61.    Var
  62.       HochFound:Boolean;
  63.       Index:Byte;
  64.    Begin
  65.       With Aufgabe Do Begin
  66.          HochFound:=False;
  67.          Index:=1;
  68.  
  69.          Repeat               (* Aufgabe suchen *)
  70.             If Hoch[Index] Then
  71.                HochFound:=True     (* eine gefunden *)
  72.             Else
  73.                Index:=Index+1;
  74.          Until (HochFound) Or (Index>AnzahlHoch);
  75.  
  76.          If HochFound Then Begin
  77.                               (* falls gefunden, dann *)
  78.                               (* entsprechend aufrufen *)
  79.             Hoch[Index]:=False; (* wieder löschen *)
  80.             PLogHoch(Index);  (* für Debug *)
  81.             If      Index=1 Then PHoch1 (* umständlich, *)
  82.             Else If Index=2 Then PHoch2 (* aber immer *)
  83.             Else If Index=3 Then PHoch3 (* korrekt, dazu *)
  84.             Else If Index=4 Then PHoch4 (* siehe Text *)
  85.             Else                 PHoch5 (* hier Index=5 *)
  86.             End               (* hohe Priorität *)
  87.          End;                 (* zu With Aufgabe *)
  88.  
  89.          VerzweigHoch:=HochFound;  (* Ergebnis übergeben *)
  90.  
  91.    End;                       (* von VerzweigHoch *)
  92.  
  93.    Function VerzweigFifo:Boolean;
  94.    Var
  95.       Index:Byte;
  96.    Begin
  97.       With Aufgabe Do Begin
  98.  
  99.          If (FifoLeer=False) Then Begin
  100.             Index:=FifoIndexOut; (* zwischenspeichern *)
  101.             If FifoIndexOut=AnzahlFifo Then
  102.                FifoIndexOut:=1
  103.             Else
  104.                FifoIndexOut:=FifoIndexOut+1;
  105.             If FifoIndexOut=FifoIndexIn Then
  106.                FifoLeer:=True;
  107.             PLogFifo(Fifo[Index].Nummer,Fifo[Index].Param);
  108.                               (* wieder nur für Debug *)
  109.  
  110.                               (* die folgenden Abfragen *)
  111.                               (* sind wieder umständlich *)
  112.                               (* dafür aber richtig, *)
  113.                               (* siehe wieder Text *)
  114.             If Fifo[Index].Nummer>4 Then
  115.                If Fifo[Index].Nummer>6 Then
  116.                   If Fifo[Index].Nummer=8 Then
  117.                      PFifo8(Fifo[Index].Param)
  118.                   Else
  119.                      PFifo7(Fifo[Index].Param)
  120.                Else           (* Fifo[Index].Nummer<=6 *)
  121.                   If Fifo[Index].Nummer=6 Then
  122.                      PFifo6(Fifo[Index].Param)
  123.                   Else
  124.                      PFifo5(Fifo[Index].Param)
  125.             Else              (* Fifo[Index].Nummer<=4 *)
  126.                If Fifo[Index].Nummer>2 Then
  127.                   If Fifo[Index].Nummer=4 Then
  128.                      PFifo4(Fifo[Index].Param)
  129.                   Else
  130.                      PFifo3(Fifo[Index].Param)
  131.                Else           (* Fifo[Index].Nummer<=2 *)
  132.                   If Fifo[Index].Nummer=2 Then
  133.                      PFifo2(Fifo[Index].Param)
  134.                   Else
  135.                      PFifo1(Fifo[Index].Param);
  136.  
  137.             VerzweigFifo:=True;
  138.             End               (* FifoLeer=False *)
  139.  
  140.          Else                 (* jetzt ist Fifo leer *)
  141.             VerzweigFifo:=False;
  142.       End;                    (* zu With Aufgabe *)
  143.  
  144.    End;                       (* von VerzweigFifo *)
  145.  
  146.    Function VerzweigPeriodic:Boolean;
  147.    Var
  148.       PerTime:Real;
  149.       Index,IndexFound:Byte;
  150.    Begin
  151.       With Aufgabe Do Begin
  152.          Index:=PeriodicIndexOut;  (* zwischenspeichern *)
  153.          PerTime:=FastUnendlich;
  154.  
  155.          Repeat               (* suche Aufgabe *)
  156.             If Periodic[Index].ZuTun Then
  157.                If Periodic[Index].Zeit<PerTime Then Begin
  158.                               (* Aufgabe soll zuerst dran *)
  159.                               (* weil sie kleinere Soll- *)
  160.                               (* zeit hat *)
  161.                   PerTime:=Periodic[Index].Zeit;
  162.                   IndexFound:=Index;
  163.                   End;
  164.             If Index=AnzahlPeriodic Then
  165.                Index:=1
  166.             Else
  167.                Index:=Index+1;
  168.          Until Index=PeriodicIndexOut;
  169.  
  170.                               (* Index für nächste Per. *)
  171.          If PeriodicIndexOut=AnzahlPeriodic Then
  172.             PeriodicIndexOut:=1
  173.          Else
  174.             PeriodicIndexOut:=PeriodicIndexOut+1;
  175.  
  176.          If PerTime<=TimeNow Then Begin
  177.                               (* Zeit ist erreicht, zu *)
  178.                               (* der Aufgabe erfüllt sein *)
  179.                               (* sollte *)
  180.             Periodic[IndexFound].ZuTun:=False;
  181.             PLogPeriodic(IndexFound);        (* für Debug *)
  182.  
  183.                               (* für die folgenden Ab- *)
  184.                               (* fragen siehe wieder Text *)
  185.             If      IndexFound=1 Then PPeriodic1
  186.             Else If IndexFound=2 Then PPeriodic2
  187.             Else If IndexFound=3 Then PPeriodic3
  188.             Else If IndexFound=4 Then PPeriodic4
  189.             Else       PPeriodic5; (* hier IndexFound=5 *)
  190.  
  191.             VerzweigPeriodic:=True;
  192.             End               (* PerTime<=TimeNow *)
  193.  
  194.          Else                 (* keine Aufgabe *)
  195.  
  196.             VerzweigPeriodic:=False;
  197.  
  198.       End;                    (* zu With Aufgabe *)
  199.  
  200.    End;                       (* von VerzweigPeriodic *)
  201.  
  202.                               (* damit sind lokale Funk- *)
  203.                               (* tionen beendet *)
  204. Begin                         (* von Schedul *)
  205.  
  206.                               (* Initialisierung des *)
  207.                               (* Schedulers muß erfolgt *)
  208.                               (* sein und mindestens *)
  209.                               (* eine Aufgabe anstehen *)
  210.  
  211.    BeginZeit:=TimeNow;        (* rette Zeit, wann Schedul *)
  212.                               (* beginnt *)
  213.  
  214.    Repeat                     (* hier beginnt Scheduling *)
  215.  
  216.                               (* zuerst hohe Priorität *)
  217.       If VerzweigHoch=False Then
  218.                               (* nur weiter suchen, falls *)
  219.                               (* keine Aufgabe mit hoher *)
  220.                               (* Priorität zu erledigen *)
  221.  
  222.                               (* dann Fifo *)
  223.          If VerzweigFifo=False Then
  224.                               (* nur weiter suchen, falls *)
  225.                               (* keine Aufgabe in Fifo zu *)
  226.                               (* erledigen *)
  227.  
  228.                               (* dann Periodic *)
  229.             If VerzweigPeriodic=False Then
  230.                               (* sonstige Aufgaben nur *)
  231.                               (* machen, falls keine in *)
  232.                               (* Periodic gefunden *)
  233.  
  234.                               (* Belastungszähler *)
  235.                PIncrDW(Belastungszaehler);
  236.  
  237.       Until Ende;             (* Ende des Scheduling *)
  238.  
  239.    EndeZeit:=TimeNow;         (* EndeZeit von Schedul *)
  240.  
  241.    PLogSchedul;               (* eine Art Statistik *)
  242.  
  243. End;                          (* von Schedul *)
  244.