Скачиваний:
37
Добавлен:
01.05.2014
Размер:
6 Кб
Скачать
☆
Unit Corout;

{$F+}

Interface

  Type
    ArPtr    = ^ArType;
    ArType   = Array [0..999] of Word; {Ї®¤ б⥪ - 1000 б«®ў}

    Process = Procedure;

    DescPtr  = ^ProcDesc;
    ProcDesc = Object
      { „ ­­лҐ }
      SSReg,
      SPReg  : Word;
      Stack : ArPtr;
      { ‘«Ґ¤гойЁ© Їа®жҐбб }
      Next : DescPtr;
      Constructor Init( Body:Process );
      Destructor Done;
      Procedure Set_Next( P:DescPtr );
      Function Get_Next:DescPtr;
    End;

    { -= ЋЎмҐЄв - ®зҐаҐ¤м Їа®жҐбб®ў =- }
    FIFO = Object
     private
      Root : DescPtr; { Ќ з «® ®зҐаҐ¤Ё Їа®жҐбб®ў }
     public
      Constructor Init; { €­ЁжЁ «Ё§Ёа®ў вм }
      Destructor Done; { Ћбў®Ў®¤Ёвм Ї ¬пвм }
      Procedure Include_Process( P:Process );
      Procedure Exclude_Process;
      Function Get_Root: DescPtr;
    End;

    { -= ЋЎмҐЄв - ®зҐаҐ¤м Ј®в®ўле Їа®жҐбб®ў =- }
    FIFO_Ready = Object(FIFO)
      CurProc : DescPtr; { ’ҐЄгйЁ© Їа®жҐбб }
      Constructor Init; { €­ЁжЁ «Ё§Ёа®ў вм }
      Destructor Done; { Ћбў®Ў®¤Ёвм Ї ¬пвм }
      Procedure Run_Manager; { ‡ ЇгбвЁвм ¤ЁбЇҐвзҐа }
      Procedure Stop_Manager; { Ћбв ­®ўЁвм ¤ЁбЇҐвзҐа }
      Procedure Add_New_Process( P:Process ); { „®Ў ўЁвм ­®ўл© Їа®жҐбб }
      Procedure Activate_Next; { ЂЄвЁўЁа®ў вм б«Ґ¤гойЁ© }
    End;

Var ReadyList : FIFO_Ready;

Procedure Transfer(OldProc,NewProc:descptr);

{ Џа®жҐбб, Є®в®ал© ўбҐЈ¤  ў ®зҐаҐ¤Ё Ј®в®ўле }
Procedure Idler;

Var main : descptr;

{--------------------------------------------------------------------------}
Implementation

Uses DOS;

{ ‡¤Ґбм Ўг¤Ґ¬ еа ­Ёвм бв ал© ®Ўа Ў®взЁЄ ЇаҐалў ­Ёп 08 }
Var Int08Save : Pointer;

{ -= ЋЎмҐЄв - ®зҐаҐ¤м Їа®жҐбб®ў =- }
Procedure ProcDesc.Set_Next( P:DescPtr );
Begin
  { ‘‹…„“ћ™€‰ := ...    ; }
  Next := P;
End;

Function ProcDesc.Get_Next:DescPtr;
Begin
  { ЏЋ‹“—€’њ_‘‹…„“ћ™€‰ :=  ‘‹…„“ћ™€‰; }
  Get_Next := Next;
End;

{ ЏђЋ–…‘‘.€Ќ€–€Ђ‹€‡€ђЋ‚Ђ’њ; }
Constructor ProcDesc.Init( Body:Process );
Begin
{  ‘Ћ‡„Ђ’њ_‘ЋЏђЋѓђЂЊЊ“;
  ‡ЂЏЋ‹Ќ€’њ ЏЋ‹… Ђ„ђ…‘_‘’…ЉЂ; }
  New(Stack);
  SSReg := seg(Stack^);
  SPReg := ofs(Stack^) + 1998 - 14;
  memw[ssreg:spreg+2] := ofs(body);
  memw[ssreg:spreg+4] := seg(body);
End;

{--------------------------------------------------------------------------}
Destructor ProcDesc.Done;
Begin
 { Ћ‘‚ЋЃЋ„€’њ ЏЂЊџ’њ, ‡ЂЌџ’“ћ ЏЋ„ ‘’…Љ; }
  Dispose(Stack)
End;

{-----------------------------------------------------}
{$F+}
Procedure Transfer(OldProc, NewProc : descptr); Assembler;
Asm                    {Є®¬ЇЁ«пв®а Ї®б«Ґ Call Transfer
                        Ї®¤бв ў«пҐв push bp; mov bp,sp}
   les di,oldproc
   mov es:[di],ss      {oldproc.ssreg := ss;}
   mov es:[di+2],sp    {oldproc.spreg := sp;  ¤аҐб ў®§ўа в  ў sp+2}
   les di,newproc
   mov ss,es:[di]      {ss := newproc.ssreg;}
   mov sp,es:[di+2]    {sp := newproc.spreg;}
   sti    { ђ §аҐи Ґ¬ ЇаҐалў ­Ёп !!! Џ®пў«пҐвбп, ­ зЁ­ п б « Ўл 2 }
   pop bp      {ўлв «ЄЁў ­ЁҐ bp ўлў®¤Ёв б⥪ ­   ¤аҐб ў®§ўа в }
   ret 8
       {§ в®«Є­г«Ё 8 Ў ©в®ў - 4 б«®ў  - §­ зҐ­Ёп oldproc Ё newproc}
End {Transfer};

{ -= "‡ ЇаҐвЁвм ЇаҐалў ­Ёп" =- }
Procedure Disable_Interrupt; Assembler;
Asm
  cli { CLose Interrupts }
End;

{ -= "ђ §аҐиЁвм ЇаҐалў ­Ёп" =- }
Procedure Enable_Interrupt; Assembler;
Asm
  sti { Stay Interrupts }
End;

{--------------------------------------------------------------------------}
{ -= Џа®жҐ¤га -®Ўа Ў®взЁЄ ЇаҐалў ­Ёп ®в в ©¬Ґа  =- }
Procedure Handler; Interrupt;
Begin
  { ‚л§лў Ґ¬ бв ал© ®Ўа Ў®взЁЄ в ©¬Ґа  (Є®в®ал© ¬л § ¬ҐбвЁ«Ё) }
  Asm Int 60h End;
  { ‡ ЇаҐй Ґ¬ ЇаҐалў ­Ёп }
  Disable_Interrupt;
  { ЂЄвЁўЁ§Ёа®ў вм б«Ґ¤гойЁ© Їа®жҐбб }
  ReadyList.Activate_Next;
End;

{ ‚ᥣ¤  ў ®зҐаҐ¤Ё Ј®в®ўле }
Procedure Idler;
Begin
  While True do;
End;

{ -= ЋЎмҐЄв - ®зҐаҐ¤м Їа®жҐбб®ў =- }
Constructor FIFO.Init; { €­ЁжЁ «Ё§Ёа®ў вм }
Begin
  { ЌЂ—Ђ‹Ћ := NIL; }
  Root := nil;
End;

Destructor FIFO.Done; { Ћбў®Ў®¤Ёвм Ї ¬пвм }
Var Cur : DescPtr;
Begin
  { (–ЁЄ« Ї® ўбҐ¬ Їа®жҐбб ¬ ®зҐаҐ¤Ё)
   ЏђЋ–…‘‘.Ћ‘‚ЋЃЋ„€’њ_ЏЂЊџ’њ; }
  While Root<>nil do begin
    Cur := Root;
    Root := Root^.Next;
    Dispose(Cur,Done); { “¤ «пҐ¬ б ўл§®ў®¬ ¤ҐбвагЄв®а  }
  end;
End;

Procedure FIFO.Include_Process( P:Process );
Var Cur : DescPtr;
Begin
  New(Cur);
  Cur^.Init(P);
  Cur^.Next := Root;
  Root := Cur;
End;

Procedure FIFO.Exclude_Process;
Begin
End;

Function FIFO.Get_Root: DescPtr;
Begin
  { ЏЋ‹“—€’њ_ЌЂ—Ђ‹Ћ := ЌЂ—Ђ‹Ћ; }
  Get_Root := Root;
End;

{ -= ЋЎмҐЄв - ®зҐаҐ¤м Ј®в®ўле Їа®жҐбб®ў =- }
Constructor FIFO_Ready.Init; { €­ЁжЁ «Ё§Ёа®ў вм }
Begin
  FIFO.Init; { Ћ—…ђ…„њ.€Ќ€–€Ђ‹€‡€ђЋ‚Ђ’њ; }
End;

Destructor FIFO_Ready.Done; { Ћбў®Ў®¤Ёвм Ї ¬пвм }
Begin
  FIFO.Done; { Ћ—…ђ…„њ.Ћ‘‚ЋЃЋ„€’њ_ЏЂЊџ’њ; }
End;

Procedure FIFO_Ready.Run_Manager; { ‡ ЇгбвЁвм ¤ЁбЇҐвзҐа }
Begin
  { ‡ЂЏђ…’€’њ_Џђ…ђ›‚ЂЌ€џ; }
  Disable_Interrupt; { ‡ ЇаҐвЁвм_ЇаҐалў ­Ёп }
  { Џ…ђ…“‘’ЂЌЋ‚€’њ_‚…Љ’Ћђ_Џђ…ђ›‚ЂЌ€џ_Ћ’_’Ђ‰Њ…ђЂ; }
  GetIntVec($08,Int08Save); { ‘®е࠭塞 бв ал© ®Ўа Ў®взЁЄ ЇаҐалў ­Ёп }
  SetIntVec($60,Int08Save);
  { “‘’ЂЌЋ‚€’њ_ЌЂ_‚…Љ’Ћђ_8_ЏђЋ–…„“ђ“_Handler; }
  SetIntVec($08,Addr(Handler)); { “бв ­ ў«Ёў Ґ¬ бў®© ®Ўа Ў®взЁЄ ЇаҐалў ­Ёп }
  { ЏЋ‹“—€’њ_ЌЂ—Ђ‹Ћ; }
  CurProc := Root;
  { €‘Љ‹ћ—€’њ_ЏђЋ–…‘‘; }
  { Џ…ђ…„Ђ’њ_“ЏђЂ‚‹…Ќ€…; }
  Transfer(main,Root);
End;

Procedure FIFO_Ready.Stop_Manager; { Ћбв ­®ўЁвм ¤ЁбЇҐвзҐа }
Begin
  { ‡ЂЏђ…’€’њ_Џђ…ђ›‚ЂЌ€џ; }
  Disable_Interrupt; { ‡ ЇаҐвЁвм_ЇаҐалў ­Ёп }
  { ‚Ћ‘‘’ЂЌЋ‚€’њ_‚…Љ’Ћђ_Џђ…ђ›‚ЂЌ€џ_Ћ’_’Ђ‰Њ…ђЂ; }
  SetIntVec($08,Int08Save); { “бв ­ ў«Ёў Ґ¬ ®Ўа в­® ®Ўа Ў®взЁЄ }
  { Џ…ђ…„Ђ’њ_“ЏђЂ‚‹…Ќ€…; (ў Ј« ў­го Їа®Ја ¬¬г) }
  Transfer(CurProc,main);
End;

Procedure FIFO_Ready.Add_New_Process( P:Process ); { „®Ў ўЁвм ­®ўл© Їа®жҐбб }
Begin
  Include_Process(P);
End;

Procedure FIFO_Ready.Activate_Next; { ЂЄвЁўЁа®ў вм б«Ґ¤гойЁ© }
Var LastProc : DescPtr;
Begin
  LastProc := CurProc;
  CurProc := LastProc^.Get_Next;
  If CurProc = nil then CurProc := Root;
  Transfer(LastProc,CurProc);
End;

Begin
  New(main);
End {Corout}.
Соседние файлы в папке LAB3