------------------------------------------
--Laboratory work #1. Ada. Semaphore
--
--Task: MA = min(Z)*MO+d*(MK*MS)
--
--Author: Igor Dudchenko, IO-61
--Date: 12.03.2019
--
------------------------------------------

with Ada.Text_IO; use Ada.Text_IO;
with Ada.Numerics.Real_Arrays;  use Ada.Numerics.Real_Arrays;
with System.Multiprocessors; use System.Multiprocessors;
with Ada.Synchronous_Task_Control; use Ada.Synchronous_Task_Control;

procedure Lab1 is
   N : Integer := 4;
   H : Integer := N / 2;

   type Vector is array(1..N) of Integer;
   type Matrix is array(1..N) of Vector;

   z : Integer := 100;
   d : Integer;
   MK : Matrix;
   MA : Matrix;

   Z : Vector;
   z_half: Integer;
   MO : Matrix;
   MS : Matrix;

   S1, S2, S3, Sk1, Sk2 : Suspension_Object;

   procedure Input(matr : out Matrix; num : in Integer) is
   begin
      for i in 1..N loop
         for j in 1..N loop
            matr(i)(j) := num + j - i;
         end loop;
      end loop;
   end Input;

   procedure Input(vec : out Vector; num : in Integer) is
   begin
      for i in 1..N loop
         vec(i) := num + i;
      end loop;
   end Input;

   procedure Output(vect : in Vector) is
   begin
      for i in 1..N loop
         Put(Integer'Image(vect(i)));
      end loop;
      Put_Line("");
   end Output;


   procedure Output(matr : in Matrix) is
   begin
      for i in 1..N loop
         Output(matr(i));
      end loop;
   end Output;


   task T1 is
      pragma Priority(1);
      pragma CPU(0);
      pragma Storage_Size(100_000_000);
   end;

   task body T1 is
      rand : Integer := 1;
      z1 : Integer;
      MK1 : Matrix;
      d1 : Integer;
      Alloc : Matrix;
      tmp : Integer;
   begin
      Put_Line("T1 started");

      ----INPUT
      d := rand;
      Input(vec => Z, num => rand);
      Input(matr => MK, num => rand);

      -----Signal
      Set_True(S1);

      -----Wait
      Suspend_Until_True(S2);

     -----Minimum
      minimum : Integer := Z(1);

      for I+1 in 1..H loop
         if z(I) < minimum then
            minimum := z(I);

     z_half = minimum;

      -----Copy
      Suspend_Until_True(Sk1);
      if z > z_half then
         z = z_half;

      -----Signal
      Set_True(Sk1);

     -----Copy
      Suspend_Until_True(Sk2);
      z1 := z;
      MK1 := Mk;
      d1 := d;
      Set_True(Sk2);

      -----compute
      for i in 1..N loop
         for j in 1..H  loop
            Alloc(i)(j) := 0;
            for k in 1..N loop
               Alloc(i)(j):=Alloc(i)(j)+d1*(MK1(i)(k)*MS(k)(j));
            end loop;
         end loop;
      end loop;

      for i in 1..N loop
         for j in 1..H  loop
            MO(i)(j):=MO(i)(j)*z1;

      for i in 1..N loop
         for j in 1..H  loop
            MA(i)(j):=Alloc(i)(j)+MO(i)(j);

      Set_True(S3);
      Put_Line("T1 finished");
   end;


   task T2 is
      pragma Priority(1);
      pragma CPU(1);
      pragma Storage_Size(100_000_000);
   end;

   task body T2 is
      rand : Integer := 1;
      MO1 : Matrix;
      MS1: Matrix;
      Alloc : Matrix;
      tmp : Integer;
   begin
      Put_Line("T2 started");

      ----Input
      Input(MO, rand);
      Input(MS, rand);

      ----Signal
      Set_True(S2);

      -----Wait
      Suspend_Until_True(S1);

     -----Minimum
      minimum : Integer := Z(1);

      for I+1 in 1..H loop
         if z(I) < minimum then
            minimum := z(I);

     z_half = minimum;

      -----Copy
      Suspend_Until_True(Sk1);
      if z > z_half then
         z = z_half;

      -----Signal
      Set_True(Sk1);

     -----Copy
      Suspend_Until_True(Sk2);
      z2:= z;
      MK2 := Mk;
      d2 := d;
      Set_True(Sk2);

      -----compute
      for i in 1..N loop
         for j in 1..H  loop
            Alloc(i)(j) := 0;
            for k in 1..N loop
               Alloc(i)(j):=Alloc(i)(j)+d1*(MK1(i)(k)*MS(k)(j));
            end loop;
         end loop;
      end loop;

      for i in 1..N loop
         for j in 1..H  loop
            MO(i)(j):=MO(i)(j)*z1;

      for i in 1..N loop
         for j in 1..H  loop
            MA(i)(j):=Alloc(i)(j)+MO(i)(j);

      Suspend_Until_True(S3);

      Output(MA);
      Put_Line("T2 finished");
   end;

begin
   Set_True(S0);
   Put_Line("Main start");
   null;
end Lab1;