-----------------------------------------------
---------------------------------
------------------------------------------------------------------------------
-- Cheddar is a GNU GPL real time scheduling analysis tool.
-- This program provides services to automatically check performances
-- of real time architectures.
--
-- Copyright (C) 2002-2010,  by Frank Singhoff, Alain Plantec, Jerome Legrand
--
-- The Cheddar project was started in 2002 by
-- the LISyC Team, University of Western Britanny.
--
-- Since 2008, Ellidiss technologies also contributes to the development of
-- Cheddar and provides industrial support.
--
-- 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: 523 $
--    $Date: 2012-09-26 15:09:39 +0200 (Wed, 26 Sep 2012) $
--    $Author: fotsing $
------------------------------------------------------------------------------
------------------------------------------------------------------------------
with Xml_Tag;     use Xml_Tag;
with double_util; use double_util;
with Translate;   use Translate;

package body Scheduler.Fixed_Priority.Dm is

   procedure Initialize (A_Scheduler : in out Dm_Scheduler) is
   begin
      Reset (A_Scheduler);
      A_Scheduler.parameters.scheduler_type := Deadline_Monotonic_Protocol;
   end Initialize;

   function Copy
     (A_Scheduler : in Dm_Scheduler)
      return        Generic_Scheduler_Ptr
   is
      Ptr : Dm_Scheduler_Ptr;

   begin

      Ptr := new Dm_Scheduler;

      Ptr.parameters         := A_Scheduler.parameters;
      Ptr.Previously_Elected := A_Scheduler.Previously_Elected;
      Ptr.Used_Resource      := A_Scheduler.Used_Resource;

      return Generic_Scheduler_Ptr (Ptr);

   end Copy;

   procedure Check_Before_Scheduling
     (My_Scheduler   : in Dm_Scheduler;
      My_Tasks       : in Tasks_Set;
      Processor_Name : in Unbounded_String)
   is

   begin

      null;

   end Check_Before_Scheduling;

   procedure Compute_Response_Time
     (My_Scheduler   : in Dm_Scheduler;
      My_Tasks       : in out Tasks_Set;
      Processor_Name : in Unbounded_String;
      Msg            : in out Unbounded_String;
      Response_Time  : out Response_Time_Table)
   is

   begin

      -- check if tasks are periodics
      --
      Periodic_Control (My_Tasks, Processor_Name);

      -- Check processor utilization first
      --
      if (Processor_Utilization_Over_Period (My_Tasks, Processor_Name) >
          1.0)
      then
         raise Processor_Utilization_Exceeded;
      end if;

      -- check start time
      --
      Start_Time_Control (My_Tasks, Processor_Name);

      -- check offset
      --
      Offset_Control (My_Tasks, Processor_Name);

      -- Compute response time
      --
      Scheduler.Fixed_Priority.Compute_Response_Time
        (Fixed_Priority_Scheduler (My_Scheduler),
         My_Tasks,
         Processor_Name,
         Msg,
         Response_Time);

   end Compute_Response_Time;

   procedure Utilization_Factor_Feasibility_Test
     (My_Scheduler   : in Dm_Scheduler;
      My_Tasks       : in Tasks_Set;
      Processor_Name : in Unbounded_String;
      Result         : in out Unbounded_String)
   is

      Bound  : Double           := 0.0;
      Utildi : Double           := 0.0;
      Msg    : Unbounded_String := empty_string;

   begin

      Start_Time_Control (My_Tasks, Processor_Name);
      Offset_Control (My_Tasks, Processor_Name);

      Utildi :=
         Processor_Utilization_Over_Deadline (My_Tasks, Processor_Name);
      Bound_On_Processor_Utilization
        (My_Scheduler,
         My_Tasks,
         Processor_Name,
         Bound,
         Msg);

      case Get_Preemptive (My_Scheduler) is

         when preemptive =>

            Result := Result & Lb_Utilization_Bound1 (Current_Language);
            Result := Result & Lb_Dm (Current_Language);

            if Utildi <= Bound then
               Result := Result & Lb_Sched_Explanation1 (Current_Language);
               Result := Result &
                         Start_Fact_Bound &
                         format (Utildi) &
                         End_Fact_Bound;
               Result := Result & Lb_Sched_Explanation12 (Current_Language);
               Result := Result &
                         Start_Fact_Bound &
                         format (Bound) &
                         End_Fact_Bound;
            else
               Result := Result & Lb_Sched_Explanation2 (Current_Language);
               Result := Result &
                         Start_Fact_Bound &
                         format (Utildi) &
                         End_Fact_Bound;
               Result := Result & Lb_Sched_Explanation22 (Current_Language);
               Result := Result &
                         Start_Fact_Bound &
                         format (Bound) &
                         End_Fact_Bound;
            end if;
            Result :=
              Result &
              Start_Ref &
              To_Unbounded_String (" (") &
              Lb_See (Current_Language) &
              To_Unbounded_String ("[7]).") &
              End_Ref &
              unbounded_lf;

         when not_preemptive =>

            Result := Result &
                      Lb_Pb_Sched_Unknown (Current_Language) &
                      unbounded_lf;
      end case;

   end Utilization_Factor_Feasibility_Test;

end Scheduler.Fixed_Priority.Dm;