------------------------------------------------------------------------------
------------------------------------------------------------------------------
-- Cheddar is a GNU GPL real-time scheduling analysis tool.
-- This program provides services to automatically check schedulability and
-- other performance criteria of real-time architecture models.
--
-- Copyright (C) 2002-2016, Frank Singhoff, Alain Plantec, Jerome Legrand
--
-- The Cheddar project was started in 2002 by 
-- Frank Singhoff, Lab-STICC UMR 6285 laboratory, Université de Bretagne Occidentale
-- 
-- Cheddar has been published in the "Agence de Protection des Programmes/France" in 2008. 
-- Since 2008, Ellidiss technologies also contributes to the development of 
-- Cheddar and provides industrial support.
--
-- The full list of contributors and sponsors can be found in AUTHORS.txt and SPONSORS.txt
--
-- This program is free software; you can redistribute it and/or modify
-- it under the terms of the GNU General Public License as published by
-- the Free Software Foundation; either version 2 of the License, or
-- (at your option) any later version.
--
-- This program is distributed in the hope that it will be useful,
-- but WITHOUT ANY WARRANTY; without even the implied warranty of
-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-- GNU General Public License for more details.
--
-- You should have received a copy of the GNU General Public License
-- along with this program; if not, write to the Free Software
-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
--
--
-- Contact : cheddar@listes.univ-brest.fr
--           
------------------------------------------------------------------------------
-- Last update : 
--    $Rev: 1249 $
--    $Date: 2014-08-28 07:02:15 +0200 (Fri, 28 Aug 2014) $
--    $Author: singhoff $
------------------------------------------------------------------------------
------------------------------------------------------------------------------

with Text_IO;             use Text_IO;
with Translate;           use Translate;
with unbounded_strings;   use unbounded_strings;
with Scheduler;           use Scheduler;
with Scheduling_Analysis; use Scheduling_Analysis;
use Scheduling_Analysis.Double_Tasks_Parameters_Package;
with Tasks;                             use Tasks;
use Tasks.Generic_Task_List_Package;
with Task_Set;                          use Task_Set;
with Offsets;               use Offsets;
with Offsets.extended;      use Offsets.extended;
with Task_Dependencies;   use Task_Dependencies;
with Dependencies;        use Dependencies;

package body Feasibility_Test.generated_R2 is

procedure compute_less_equal 
(My_Tasks      : in Tasks_Set;
Processor_Name : in Unbounded_String;
Current_Task : in Generic_Task_Ptr;
Value_W_i : out MY_ARRAY;
q: out integer)
is
  My_Iterator : Tasks_Iterator;
  Taski    : Generic_Task_Ptr; 
  rightvalue  : Double; 
  leftvalue : Double;
  k: integer:=0;
begin 
reset_iterator (My_Tasks, My_Iterator);
current_element (My_Tasks, Taski, My_Iterator);
rightvalue := 0.0;
leftvalue :=0.0; 
Value_W_i(0):=1.0;
While (Value_W_i(k) >=  rightvalue)  loop     
  leftvalue :=Double(W_i(My_Tasks,Double(k),Taski)) ; 							 
  rightvalue :=Double(Periodic_Task_Ptr(Taski).period)*Double(1.0+Double(k));    
  Value_W_i(k):= leftvalue;
  k:=k+1;
end loop;
q:=k;
end compute_less_equal;

function W_i				 
(My_Tasks     : in Tasks_Set;
q:in Double;
Current_Task : in Generic_Task_Ptr
)
return     Double
is
Iterator : Tasks_Iterator;
Taski, Taskj    : Generic_Task_Ptr;
calcul, tmp   : Double;
begin
calcul := 0.0;
tmp:=-0.1;
current_element (My_Tasks, Taski, Iterator);
While (tmp/=calcul)  loop
 reset_iterator (My_Tasks, Iterator);
 tmp :=calcul;
  calcul :=  (Double(Current_Task.capacity))*(1.0+q);
   loop
     current_element (My_Tasks, Taskj, Iterator);
     if (Taskj.priority > Current_Task.priority) then
       calcul := calcul + double((Double(Taskj.capacity))*(Double'Ceiling((Double(Periodic_Task_Ptr (Taskj).jitter)+tmp)/(Double(Periodic_Task_Ptr (Taskj).period)))));
      end if;
    exit when is_last_element (My_Tasks, Iterator);
    next_element (My_Tasks, Iterator);
   end loop;
end loop; 
return calcul;
end W_i;

function max_r_i
(My_Tasks     : in Tasks_Set;
W_i           : in MY_ARRAY;
nb_value_W_i  : in integer;
Current_Task  : in Generic_Task_Ptr
)
return  Double
is
My_Iterator : Tasks_Iterator;
Taski    : Generic_Task_Ptr;       
q : integer;
calcul,max : Double;
begin
  calcul := 0.0;
  current_element (My_Tasks, Taski, My_Iterator);
  max :=0.0;
  for q in 0..nb_value_W_i loop
    calcul := Double(Periodic_Task_Ptr(Taski).jitter)+Double(Periodic_Task_Ptr(Taski).blocking_time) + W_i(q)-Double(q)*Double(Periodic_Task_Ptr(Taski).period);
  if calcul > max then
   max:=calcul;
  end if;
end loop;
return max;
end max_r_i;

end Feasibility_Test.generated_R2;