Скачиваний:
37
Добавлен:
01.05.2014
Размер:
6.11 Кб
Скачать
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