------------------------------------------------------------------------------ ------------------------------------------------------------------------------ -- 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-2023, Frank Singhoff, Alain Plantec, Jerome Legrand, -- Hai Nam Tran, Stephane Rubini -- -- The Cheddar project was started in 2002 by -- Frank Singhoff, Lab-STICC UMR 6285, 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 README.md -- -- 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$ -- $Date$ -- $Author: singhoff $ ------------------------------------------------------------------------------ ------------------------------------------------------------------------------ with unbounded_strings; use unbounded_strings; with version; use version; with translate.francais_labels; use translate.francais_labels; with translate.english_labels; use translate.english_labels; package body translate.aadl_labels is procedure initialize is begin if (Current_Language = english) then lb_task (Current_Language) := To_Unbounded_String ("Thread component"); lb_compute_buffer (Current_Language) := To_Unbounded_String ("Event data port analysis with feasibility tests"); lb_draw_buffer (Current_Language) := To_Unbounded_String ("Event data port analysis from scheduling simulation"); lb_compute_and_update (Current_Language) := To_Unbounded_String ("Compute and Update thread components"); lb_compute_and_update_one_step (Current_Language) := To_Unbounded_String ("Compute and Update thread components : one step "); lb_check_and_update_address_space (Current_Language) := To_Unbounded_String ("Check and update process component"); lb_check_address_space (Current_Language) := To_Unbounded_String ("Check process component"); lb_update_task (Current_Language) := To_Unbounded_String ("Update thread components"); lb_update_address_space (Current_Language) := To_Unbounded_String ("Update process components"); lb_update_resource (Current_Language) := To_Unbounded_String ("Update data components"); lb_update_buffer (Current_Language) := To_Unbounded_String ("Update event data ports"); lb_update_processor (Current_Language) := To_Unbounded_String ("Update processor components"); lb_resource_not_found (Current_Language) := To_Unbounded_String ("Data component not found"); lb_task_not_found (Current_Language) := To_Unbounded_String ("Thread component not found"); lb_address_space_not_found (Current_Language) := To_Unbounded_String ("Process component not found"); lb_buffer_not_found (Current_Language) := To_Unbounded_String ("Event data port not found"); lb_processor_not_found (Current_Language) := To_Unbounded_String ("Processor component not found"); lb_define_tasks_before (Current_Language) := To_Unbounded_String ("Define a thread component before"); lb_define_address_spaces_before (Current_Language) := To_Unbounded_String ("Define a process component before"); lb_define_resources_before (Current_Language) := To_Unbounded_String ("Define a data component before"); lb_define_buffers_before (Current_Language) := To_Unbounded_String ("Define an event data port before"); lb_define_processors_before (Current_Language) := To_Unbounded_String ("Define a processor component before"); lb_can_not_define_more_tasks (Current_Language) := To_Unbounded_String ("Can not define more thread components"); lb_can_not_define_more_address_spaces (Current_Language) := To_Unbounded_String ("Can not define more process components"); lb_can_not_define_more_resources (Current_Language) := To_Unbounded_String ("Can not define more data components"); lb_can_not_define_more_buffers (Current_Language) := To_Unbounded_String ("Can not define more event data ports"); lb_can_not_define_more_processors (Current_Language) := To_Unbounded_String ("Can not define more processor components"); -- -- Processors widgets -- lb_scheduler (Current_Language) := To_Unbounded_String ("Scheduling protocol"); lb_select_processor_first (Current_Language) := To_Unbounded_String ("Select a processor component first"); lb_file_name_control (Current_Language) := To_Unbounded_String ("Invalid file name with the selected scheduling protocol"); lb_quantum_control (Current_Language) := To_Unbounded_String ("Invalid quantum with selected scheduling protocol"); lb_processor (Current_Language) := To_Unbounded_String ("Processor component "); lb_processor_name (Current_Language) := To_Unbounded_String ("Processor component name"); lb_scheduler (Current_Language) := To_Unbounded_String ("Scheduling protocol"); -- -- Address space widgets -- lb_address_space_name (Current_Language) := To_Unbounded_String ("Process component name"); lb_address_space (Current_Language) := To_Unbounded_String ("Process component"); lb_select_address_space_first (Current_Language) := To_Unbounded_String ("Select a process component first"); lb_invalid_scheduler (Current_Language) := To_Unbounded_String ("Invalid scheduling protocol"); -- -- Tasks widgets -- lb_task_name (Current_Language) := To_Unbounded_String ("Thread component name"); lb_task (Current_Language) := To_Unbounded_String ("Thread component"); lb_task_type (Current_Language) := To_Unbounded_String ("Dispatch protocol"); lb_capacity (Current_Language) := To_Unbounded_String ("Compute execution time"); lb_rule_for_parametric_only (Current_Language) := To_Unbounded_String ("Activation rule only with user-defined thread component"); lb_select_task_first (Current_Language) := To_Unbounded_String ("Select a thread component first"); lb_task_not_permitted (Current_Language) := To_Unbounded_String ("Operation not permitted with the selected thread component"); lb_have_to_be_on_the_same_processor (Current_Language) := To_Unbounded_String ("have to be on the same processor component"); -- -- Buffers widgets -- lb_buffer (Current_Language) := To_Unbounded_String ("Event data port"); lb_buffer_name (Current_Language) := To_Unbounded_String ("Event data port name"); lb_select_buffer_first (Current_Language) := To_Unbounded_String ("Select an event data port first"); lb_bound_buffer (Current_Language) := To_Unbounded_String ("Bound on event data ports"); lb_buffer_information (Current_Language) := To_Unbounded_String ("Event data port information "); lb_buffer_list (Current_Language) := To_Unbounded_String ("Event data port list "); lb_role_list (Current_Language) := To_Unbounded_String ("Threads using the event data port "); -- -- Resources widgets -- lb_resource_name (Current_Language) := To_Unbounded_String ("Data component name"); lb_resource (Current_Language) := To_Unbounded_String ("Data component"); lb_select_resource_first (Current_Language) := To_Unbounded_String ("Select a data component first"); lb_update_resource_control (Current_Language) := To_Unbounded_String ("Invalid selected thread component"); lb_resource_filter (Current_Language) := To_Unbounded_String ("Select a data component"); lb_protocol (Current_Language) := To_Unbounded_String ("Concurrency control protocol"); lb_used_protocol (Current_Language) := To_Unbounded_String ("Used concurrency control protocol : "); lb_resource_state (Current_Language) := To_Unbounded_String ("Data component state (Integer)"); lb_resources (Current_Language) := To_Unbounded_String ("Data components"); lb_resource_affect (Current_Language) := To_Unbounded_String ("Data component shared by threads "); lb_resource_information (Current_Language) := To_Unbounded_String ("Data component information "); lb_invalid_protocol (Current_Language) := To_Unbounded_String ("Invalid data component concurrency control protocol "); lb_cpu_filter (Current_Language) := To_Unbounded_String ("Select a processor component"); -- -- Dependency graph widgets -- lb_new_buffer_role (Current_Language) := To_Unbounded_String ("New event data port role"); -- -- AADL options widget -- lb_import_aadl_event_to_precedencies (Current_Language) := To_Unbounded_String ("Transform event port to thread component precedencies"); lb_import_aadl_event_data_to_precedencies (Current_Language) := To_Unbounded_String ("Transform event data port to thread component precedencies"); lb_export_aadl_precedencies_to_event (Current_Language) := To_Unbounded_String ("Transform thread component precedencies to event port connections"); lb_export_aadl_precedencies_to_event_data (Current_Language) := To_Unbounded_String ("Transform thread component precedencies to event data port connections"); lb_export_aadl_precedencies_to_properties (Current_Language) := To_Unbounded_String ("Transform thread component precedencies to Cheddar's properties"); -- -- System entity checks -- lb_are_unconsistent (Current_Language) := To_Unbounded_String (" are unconsistent"); ---------------------------------------------------- -- Seed options ---------------------------------------------------- lb_task_specific (Current_Language) := To_Unbounded_String ("Thread component specific seed"); lb_all_predictable (Current_Language) := To_Unbounded_String ("Predictable for all thread components"); lb_all_unpredictable (Current_Language) := To_Unbounded_String ("Unpredictable for all thread components"); -- -- Shared resources logic -- lb_compute_blocking_error1 (Current_Language) := To_Unbounded_String ("All data components have to use the same concurrency control protocol."); lb_compute_blocking_error2 (Current_Language) := To_Unbounded_String ("Concurrency control protocol error : shared data components use protocol which does not work with the selected scheduling protocol."); lb_compute_blocking_error3 (Current_Language) := To_Unbounded_String ("Can not compute bound on blocking time with such shared data component concurrency control protocol."); lb_has_priority_inversion (Current_Language) := To_Unbounded_String (" has a priority inversion on the data component"); lb_blocking_time_inject_success (Current_Language) := To_Unbounded_String ("Thread component blocking times are updated."); lb_blocking_time_inject_failed (Current_Language) := To_Unbounded_String ("Thread component blocking times are not updated."); -- -- Scheduling logic -- lb_feasibility_number2 (Current_Language) := To_Unbounded_String ("2) Feasibility test based on worst case thread component response time : "); lb_priorities_error1 (Current_Language) := To_Unbounded_String ("Thread components must be periodic : can not set priorities."); lb_priorities_error2 (Current_Language) := To_Unbounded_String ("Processor without tasks : can not set priorities."); lb_sched_explanation1 (Current_Language) := To_Unbounded_String ("the thread component set is schedulable because the processor utilization factor "); lb_sched_explanation2 (Current_Language) := To_Unbounded_String ("the thread component set is not schedulable because the processor utilization factor "); lb_sched_explanation3 (Current_Language) := To_Unbounded_String ("we can not prove that the thread component set is schedulable because the processor utilization factor "); lb_sched_explanation5 (Current_Language) := To_Unbounded_String ("the thread component set is schedulable because for each thread component "); lb_sched_explanation6 (Current_Language) := To_Unbounded_String ("the thread component set is not schedulable because "); lb_sched_explanation62 (Current_Language) := To_Unbounded_String ("one or many thread components doesn't/don't satisfy the processor utilization factor feasibility test"); lb_sched_explanation7 (Current_Language) := To_Unbounded_String (" List of thread components not schedulable : "); lb_sched_explanation8 (Current_Language) := To_Unbounded_String ("we can not prove that thread components are schedulable because "); lb_sched_explanation81 (Current_Language) := To_Unbounded_String ("one or many thread components doesn't/don't satisfy the processor utilization factor feasibility test"); lb_sched_explanation82 (Current_Language) := To_Unbounded_String (" List of concerned thread components : "); lb_no_deadline_missed_in_the_computed_scheduling (Current_Language) := To_Unbounded_String ("No deadline missed in the computed scheduling : the thread component is schedulable if you computed the simulation on the hyperperiod."); lb_cannot_say_if_deadline_will_be_missed_in_the_computed_scheduling (Current_Language) := To_Unbounded_String ("One or several tasks did not complete their execution : for those tasks, it is not possible to say if their deadline can be missed or not."); lb_no_deadline_will_be_missed_task_are_schedulable (Current_Language) := To_Unbounded_String ("All thread component deadlines will be met : the thread component set is schedulable."); lb_deadline_will_be_missed_task_are_not_schedulable (Current_Language) := To_Unbounded_String ("Some thread component deadlines will be missed : the thread component set is not schedulable."); lb_worst_case_task_response_time (Current_Language) := To_Unbounded_String ("Worst case thread component response time"); lb_task_response_time (Current_Language) := To_Unbounded_String ("Thread component response time"); lb_task_response_time_from_simulation (Current_Language) := To_Unbounded_String ("Thread component response time computed from simulation"); lb_partitioning_result (Current_Language) := To_Unbounded_String ("Thread component assignement after partitioning "); lb_compute_scheduling_error_1 (Current_Language) := To_Unbounded_String ("Thread component model error : can not apply the selected scheduling protocol with this thread component set."); lb_compute_scheduling_error_2 (Current_Language) := To_Unbounded_String ("Thread components must be periodic : can not compute hyperperiod with this thread component set. "); lb_compute_scheduling_error_3 (Current_Language) := To_Unbounded_String ("Thread component model error : can not compute hyperperiod with this thread component set. "); lb_compute_scheduling_error_4 (Current_Language) := To_Unbounded_String ("Thread components must have period equal to deadline : can not compute bound on response time with this thread component set. "); lb_compute_scheduling_error_5 (Current_Language) := To_Unbounded_String ("Thread components must be periodic : can not compute bound on response time with this thread component set."); lb_compute_scheduling_error_6 (Current_Language) := To_Unbounded_String ("Thread component model error : can not compute bound on response time with this thread component set."); lb_compute_scheduling_error_7 (Current_Language) := To_Unbounded_String ("Processor utilization exceeded : can not compute bound on response time with this thread component set. "); lb_compute_scheduling_error_8 (Current_Language) := To_Unbounded_String ("Internal Error : can not compute bound on response time with this thread component set."); lb_compute_scheduling_error_9 (Current_Language) := To_Unbounded_String ("Thread components must be periodic : can not compute bound on processor utilization factor with period on this thread component set. "); lb_compute_scheduling_error_10 (Current_Language) := To_Unbounded_String ("Thread component model error : can not compute processor utilization factor with period. "); lb_compute_scheduling_error_11 (Current_Language) := To_Unbounded_String ("Several thread components have same priority level : can not apply the selected scheduling protocol with this thread component set."); lb_compute_scheduling_error_12 (Current_Language) := To_Unbounded_String ("Thread component with non zero start time : can not compute bound on response time with this thread component set."); lb_compute_scheduling_error_13 (Current_Language) := To_Unbounded_String ("Thread component with non zero offset : can not compute bound on response time with this thread component set."); lb_compute_scheduling_error_14 (Current_Language) := To_Unbounded_String ("Thread component must have period equal to deadline : can not apply the selected scheduling protocol with this thread component set. "); lb_compute_scheduling_error_15 (Current_Language) := To_Unbounded_String ("Thread component must be periodic : can not apply the selected scheduling protocol with this thread component set. "); lb_compute_scheduling_error_21 (Current_Language) := To_Unbounded_String ("Thread components must have deadline > 0 : can not compute processor utilization factor with deadline on this thread component set. "); lb_periodic (Current_Language) := To_Unbounded_String ("Periodic thread component "); lb_aperiodic (Current_Language) := To_Unbounded_String ("Aperiodic thread component "); lb_poisson_process_task (Current_Language) := To_Unbounded_String ("Poisson thread component "); lb_sporadic_task (Current_Language) := To_Unbounded_String ("Sporadic thread component "); lb_parametric_task (Current_Language) := To_Unbounded_String ("User-defined thread component "); lb_task_is_not_over_response_time_is_not_computed (Current_Language) := To_Unbounded_String (" response time not computed since the thread component did not run all its compute execution time"); lb_run_simulation_on_one_processor_only (Current_Language) := To_Unbounded_String ("Schedule all processor components"); lb_run_feasibility_tests_on_one_processor_only (Current_Language) := To_Unbounded_String (" Feasibility on all processor components"); lb_partition_error1 (Current_Language) := To_Unbounded_String ("Can not do partitioning : all processor components must have the same scheduling protocol."); lb_partition_error2 (Current_Language) := To_Unbounded_String ("Can not do partitioning : you must define more processor components."); lb_partition_error3 (Current_Language) := To_Unbounded_String ("Invalid scheduling protocol : can not run scheduling partition. "); -- -- Buffer logic -- lb_buffer_utilization (Current_Language) := To_Unbounded_String ("Event data port utilization factor : "); lb_compute_buffer_error_1 (Current_Language) := To_Unbounded_String ("Data flow constraint not respected : can not compute event data port bound with this thread component set. "); lb_compute_buffer_error_2 (Current_Language) := To_Unbounded_String ("Thread components must be periodic : can not compute event data port bound with this thread component set. "); lb_compute_buffer_error_3 (Current_Language) := To_Unbounded_String ("Thread component model error : can not compute bound with several consumers. "); lb_maximum_buffer_size (Current_Language) := To_Unbounded_String ("Maximum number of messages in the event data port : "); lb_average_buffer_size (Current_Language) := To_Unbounded_String ("Average number of messages in the event data port : "); -- -- Dependencies logic -- lb_precedencies_period_error (Current_Language) := To_Unbounded_String ("Can not schedule with precedencies : thread component precedencies required that thread components have harmonic period."); lb_chetto_error2 (Current_Language) := To_Unbounded_String ("Thread components must have the same period : can not apply Chetto/Blazewicz method on this thread component set."); lb_chetto_error3 (Current_Language) := To_Unbounded_String ("Thread components model error : can not apply Chetto/Blazewicz method on this thread component set. "); else if (Current_Language = francais) then lb_task (Current_Language) := To_Unbounded_String ("Composant thread"); lb_compute_buffer (Current_Language) := To_Unbounded_String ("Analyse des event data ports par tests de faisabilité"); lb_draw_buffer (Current_Language) := To_Unbounded_String ("Analyse des event data ports par simulation d'ordonnancement"); lb_compute_and_update (Current_Language) := To_Unbounded_String ("Calculer et mettre à jour les composants thread"); lb_compute_and_update_one_step (Current_Language) := To_Unbounded_String ("Calculer et mettre à jour les composants thread : un pas "); lb_check_and_update_address_space (Current_Language) := To_Unbounded_String ("Vérification et mise jour des composants process"); lb_check_address_space (Current_Language) := To_Unbounded_String ("Vérification des composants process"); lb_update_task (Current_Language) := To_Unbounded_String ("Mise à jour des composants thread"); lb_update_address_space (Current_Language) := To_Unbounded_String ("Mise à jour des composants process"); lb_update_resource (Current_Language) := To_Unbounded_String ("Mise à jour des composants data"); lb_update_buffer (Current_Language) := To_Unbounded_String ("Mise à jour des event data ports"); lb_update_processor (Current_Language) := To_Unbounded_String ("Mise à jour des composants processor"); lb_resource_not_found (Current_Language) := To_Unbounded_String ("Composant data inconnue"); lb_task_not_found (Current_Language) := To_Unbounded_String ("Composant thread inconnu"); lb_address_space_not_found (Current_Language) := To_Unbounded_String ("Composant process inconnu"); lb_buffer_not_found (Current_Language) := To_Unbounded_String ("Event data port inconnu"); lb_processor_not_found (Current_Language) := To_Unbounded_String ("Composant processor inconnu"); lb_define_tasks_before (Current_Language) := To_Unbounded_String ("Définir un composant thread d'abord"); lb_define_address_spaces_before (Current_Language) := To_Unbounded_String ("Définir un composant process d'abord"); lb_define_resources_before (Current_Language) := To_Unbounded_String ("Définir un composant data d'abord"); lb_define_buffers_before (Current_Language) := To_Unbounded_String ("Définir un event data port d'abord"); lb_define_processors_before (Current_Language) := To_Unbounded_String ("Définir un composant processor d'abord"); lb_can_not_define_more_tasks (Current_Language) := To_Unbounded_String ("Impossible de définir d'autres composants thread"); lb_can_not_define_more_address_spaces (Current_Language) := To_Unbounded_String ("Impossible de définir d'autres composants process"); lb_can_not_define_more_resources (Current_Language) := To_Unbounded_String ("Impossible de définir d'autres composants data"); lb_can_not_define_more_buffers (Current_Language) := To_Unbounded_String ("Impossible de définir d'autres event data ports"); lb_can_not_define_more_processors (Current_Language) := To_Unbounded_String ("Impossible de définir d'autres composants processor"); -- widget lb_scheduler (Current_Language) := To_Unbounded_String ("Scheduling protocol"); -- -- Processors widgets -- lb_select_processor_first (Current_Language) := To_Unbounded_String ("Choisissez un composant processor d'abord"); lb_file_name_control (Current_Language) := To_Unbounded_String ("Nom de fichier invalide avec le scheduling protocol sélectionné"); lb_quantum_control (Current_Language) := To_Unbounded_String ("Valeur du quantum invalide avec le scheduling protocol sélectionné"); lb_processor (Current_Language) := To_Unbounded_String ("Composant processor "); lb_processor_name (Current_Language) := To_Unbounded_String ("Nom du composant processor"); lb_scheduler (Current_Language) := To_Unbounded_String ("Scheduling protocol"); -- -- Address space widgets -- lb_address_space_name (francais) := To_Unbounded_String ("Nom du composant process"); lb_address_space (francais) := To_Unbounded_String ("Composant process"); lb_invalid_scheduler (francais) := To_Unbounded_String ("Scheduling protocol invalide"); lb_select_address_space_first (francais) := To_Unbounded_String ("Choisissez un composant process d'abord"); -- -- Tasks widgets -- lb_task_name (Current_Language) := To_Unbounded_String ("Nom du composant thread"); lb_task (Current_Language) := To_Unbounded_String ("Composant thread"); lb_task_type (Current_Language) := To_Unbounded_String ("Dispatch protocol"); lb_capacity (Current_Language) := To_Unbounded_String ("Compute execution time"); lb_rule_for_parametric_only (Current_Language) := To_Unbounded_String ("Règle d'activation seulement avec un composant thread paramétrique"); lb_select_task_first (Current_Language) := To_Unbounded_String ("Choisissez un composant thread d'abord"); lb_task_not_permitted (Current_Language) := To_Unbounded_String ("Operation impossible pour le composant thread selectionné"); lb_context_switch_overhead (Current_Language) := To_Unbounded_String ("Context switch overhead"); lb_have_to_be_on_the_same_processor (Current_Language) := To_Unbounded_String ("doivent être positionnés sur le même composant processor"); -- -- Buffers widgets -- lb_buffer (Current_Language) := To_Unbounded_String ("Event data port"); lb_buffer_name (Current_Language) := To_Unbounded_String ("Nom de l'event data port"); lb_select_buffer_first (Current_Language) := To_Unbounded_String ("Choisissez un event data port d'abord"); lb_bound_buffer (Current_Language) := To_Unbounded_String ("Borne sur les event data port"); lb_buffer_information (Current_Language) := To_Unbounded_String ("Information sur l'event data port "); lb_buffer_list (Current_Language) := To_Unbounded_String ("Liste des event data port "); lb_role_list (Current_Language) := To_Unbounded_String ("Composants thread utilisant l'event data port "); -- -- Resources widgets -- lb_resource_name (Current_Language) := To_Unbounded_String ("Nom du composant data"); lb_resource (Current_Language) := To_Unbounded_String ("Composant data"); lb_select_resource_first (Current_Language) := To_Unbounded_String ("Choisissez un composant data d'abord"); lb_update_resource_control (Current_Language) := To_Unbounded_String ("Composant thread selectionné invalide"); lb_resource_filter (Current_Language) := To_Unbounded_String ("Selectionner un composant data"); lb_protocol (Current_Language) := To_Unbounded_String ("Concurrency control protocol"); lb_used_protocol (Current_Language) := To_Unbounded_String ("Concurrency control protocol utilisé : "); lb_resource_state (Current_Language) := To_Unbounded_String ("Etat du composant data (Entier)"); lb_resources (Current_Language) := To_Unbounded_String ("Composants data"); lb_resource_affect (Current_Language) := To_Unbounded_String ("Composant data partagée par les thread "); lb_resource_information (Current_Language) := To_Unbounded_String ("Information sur le composant data "); lb_invalid_protocol (Current_Language) := To_Unbounded_String ("Concurrency control protocol de partage de composant data invalide "); lb_cpu_filter (Current_Language) := To_Unbounded_String ("Selectionner un composant processor"); -- -- Dependency graph widgets -- lb_new_buffer_role (Current_Language) := To_Unbounded_String ("Nouveau rôle event data port"); -- -- AADL options widget -- lb_import_aadl_event_to_precedencies (Current_Language) := To_Unbounded_String ("Transformer les event ports en précédence de composants thread"); lb_import_aadl_event_data_to_precedencies (Current_Language) := To_Unbounded_String ("Transformer les event data ports en précédence de composants thread"); lb_export_aadl_precedencies_to_event (Current_Language) := To_Unbounded_String ("Transformer les précédences de composants thread en event ports"); lb_export_aadl_precedencies_to_event_data (Current_Language) := To_Unbounded_String ("Transformer les précédences de composants thread en event data ports"); lb_export_aadl_precedencies_to_properties (Current_Language) := To_Unbounded_String ("Transformer les précédences de composants thread en propriétés Cheddar"); ---------------------------------------------------- -- Seed options ---------------------------------------------------- lb_task_specific (Current_Language) := To_Unbounded_String ("Spécifiques aux composants thread"); lb_all_predictable (Current_Language) := To_Unbounded_String ("Prévisible pour toutes les composants thread"); lb_all_unpredictable (Current_Language) := To_Unbounded_String ("Imprévisible pour toutes les composants thread"); -- -- Shared resources logic -- lb_compute_blocking_error1 (Current_Language) := To_Unbounded_String ("Toutes les composants data doivent utiliser le même concurrency control protocol."); lb_compute_blocking_error2 (Current_Language) := To_Unbounded_String ("Erreur de concurrency control protocol : protocole de partage de composant data incompatible avec le scheduling protocol sélectionné."); lb_compute_blocking_error3 (Current_Language) := To_Unbounded_String ("Impossible de calculer une borne sur les temps de blocage avec ce concurrency control protocol."); lb_has_priority_inversion (Current_Language) := To_Unbounded_String ("est victime d'une inversion de priorité sur le composant data"); -- -- Scheduling logic -- lb_priorities_error1 (Current_Language) := To_Unbounded_String ("Composants thread non périodiques : impossible de modifier les priorités."); lb_priorities_error2 (Current_Language) := To_Unbounded_String ("Composant processor sans threads : impossible de modifier les priorités."); lb_sched_explanation1 (Current_Language) := To_Unbounded_String ("les composants thread sont ordonnancables car le taux d'utilisation processeur "); lb_sched_explanation2 (Current_Language) := To_Unbounded_String ("les composants thread ne sont pas ordonnancables car le taux d'utilisation processeur "); lb_sched_explanation3 (Current_Language) := To_Unbounded_String ("il n'est pas possible de prouver que les composants thread sont ordonnancables car le taux d'utilisation processeur "); lb_sched_explanation5 (Current_Language) := To_Unbounded_String ("le jeu de composants thread est ordonnancable car pour chaque composant thread "); lb_sched_explanation6 (Current_Language) := To_Unbounded_String ("le jeu de composants thread n'est pas ordonnancable car "); lb_sched_explanation62 (Current_Language) := To_Unbounded_String ("un ou plusieurs composants thread ne remplissent pas le test de faisabilité sur le taux d'utilisation processeur"); lb_sched_explanation7 (Current_Language) := To_Unbounded_String (" Liste des composants thread non ordonnancables : "); lb_sched_explanation8 (Current_Language) := To_Unbounded_String ("il n'est pas possible de prouver que le jeu de composants thread est ordonnancable car "); lb_sched_explanation81 (Current_Language) := To_Unbounded_String ("un ou plusieurs composants thread ne remplissent pas le test de faisabilité sur le taux d'utilisation processeur"); lb_sched_explanation82 (Current_Language) := To_Unbounded_String (" Liste des composants thread concernés : "); lb_no_deadline_missed_in_the_computed_scheduling (Current_Language) := To_Unbounded_String ("Aucune échéance de manquée dans la simulation d'ordonnancement : le jeu de composants thread semble être ordonnançable."); lb_no_deadline_will_be_missed_task_are_schedulable (Current_Language) := To_Unbounded_String ("Toutes les échéances seront respectées : le jeu de composants thread est ordonnançable."); lb_deadline_will_be_missed_task_are_not_schedulable (Current_Language) := To_Unbounded_String ("Certaines échéances ne seront pas respectées : le jeu de composants thread n'est pas ordonnançable."); lb_worst_case_task_response_time (Current_Language) := To_Unbounded_String ("Pire temps de réponse des composants thread"); lb_task_response_time (Current_Language) := To_Unbounded_String ("- Temps de réponse des composants thread : "); lb_task_response_time (Current_Language) := To_Unbounded_String ("Temps de réponse des composants thread"); lb_task_response_time_from_simulation (Current_Language) := To_Unbounded_String ("Temps de réponse des composants thread calculé à partir de la simulation"); lb_partitioning_result (Current_Language) := To_Unbounded_String ("Placement des composants thread après partitionnement"); lb_compute_scheduling_error_1 (Current_Language) := To_Unbounded_String ("Erreur sur le modèle de composant thread : le scheduling protocol sélectionnée est incompatible."); lb_compute_scheduling_error_2 (Current_Language) := To_Unbounded_String ("Composants thread non périodiques : impossible de calculer la période d'étude avec ce jeu de composants thread."); lb_compute_scheduling_error_3 (Current_Language) := To_Unbounded_String ("Erreur sur le modèle de composant thread : impossible de calculer la période d'étude avec ce jeu de composants thread."); lb_compute_scheduling_error_4 (Current_Language) := To_Unbounded_String ("Composant thread avec périodes différentes des échéances : impossible de calculer les bornes des temps de réponse avec ce jeu de composants thread."); lb_compute_scheduling_error_5 (Current_Language) := To_Unbounded_String ("Composants thread non périodiques : impossible de calculer les bornes des temps de réponse avec ce jeu de composants thread."); lb_compute_scheduling_error_6 (Current_Language) := To_Unbounded_String ("Erreur sur le modèle de composant thread : impossible de calculer les bornes des temps de réponse avec ce jeu de composants thread."); lb_compute_scheduling_error_7 (Current_Language) := To_Unbounded_String ("Taux d'utilisation trôp élevé : impossible de calculer les bornes des temps de réponse avec ce jeu de composants thread."); lb_compute_scheduling_error_8 (Current_Language) := To_Unbounded_String ("Erreur interne : impossible de calculer les bornes des temps de réponse avec ce jeu de composants thread."); lb_compute_scheduling_error_9 (Current_Language) := To_Unbounded_String ("Composants thread non périodiques : impossible de calculer un taux d'utilisation basé sur les périodes avec ce jeu de composants thread."); lb_compute_scheduling_error_10 (Current_Language) := To_Unbounded_String ("Erreur sur le modèle de composant thread : impossible de calculer un taux d'utilisation avec ce jeu de composants thread."); lb_compute_scheduling_error_11 (Current_Language) := To_Unbounded_String ("Composants thread avec priorité identique : le scheduling protocol sélectionnée est incompatible."); lb_compute_scheduling_error_12 (Current_Language) := To_Unbounded_String ("Composants thread avec date d'arrivée > à zéro : impossible de calculer les bornes des temps de réponse avec ce jeu de composants thread."); lb_compute_scheduling_error_13 (Current_Language) := To_Unbounded_String ("Composants thread avec offset différents de zéro : impossible de calculer les bornes des temps de réponse avec ce jeu de composants thread."); lb_compute_scheduling_error_14 (Current_Language) := To_Unbounded_String ("Composants thread avec périodes différentes des échéances : le scheduling protocol sélectionné est incompatible."); lb_compute_scheduling_error_15 (Current_Language) := To_Unbounded_String ("Composants thread non périodiques : le scheduling protocol sélectionné est incompatible."); lb_compute_scheduling_error_21 (Current_Language) := To_Unbounded_String ("Composants thread avec échéance nulle : impossible de calculer un taux d'utilisation basé sur les échéances avec ce jeu de composants thread."); lb_periodic (Current_Language) := To_Unbounded_String ("Le composant thread périodique "); lb_aperiodic (Current_Language) := To_Unbounded_String ("Le composant thread apériodique "); lb_poisson_process_task (Current_Language) := To_Unbounded_String ("Le composant thread processus de Poisson "); lb_sporadic_task (Current_Language) := To_Unbounded_String ("Le composant thread sporadique "); lb_parametric_task (Current_Language) := To_Unbounded_String ("Le composant thread paramétrique "); lb_task_is_not_over_response_time_is_not_computed (Current_Language) := To_Unbounded_String (" temps de reponse non calcule car le composant thread n'a pas terminé son compute execution time"); lb_run_simulation_on_one_processor_only (Current_Language) := To_Unbounded_String ("Ordonnance tous les composants processor"); lb_run_feasibility_tests_on_one_processor_only (Current_Language) := To_Unbounded_String (" Faisabilité sur tous les composants processor"); lb_partition_error1 (Current_Language) := To_Unbounded_String ("Impossible de partitionner : tous les composants processeur doivent avoir le même scheduling protocol."); lb_partition_error2 (Current_Language) := To_Unbounded_String ("Impossible de partitionner : nombre de composant processeur insuffisant."); lb_partition_error3 (Current_Language) := To_Unbounded_String ("Scheduling protocol invalide : impossible de calculer le partitionnement."); -- -- Buffer logic -- lb_compute_buffer_error_1 (Current_Language) := To_Unbounded_String ("Contrainte de débit non respectée : impossible de calculer la borne de l'event data port tampon avec ce jeu de composants thread."); lb_compute_buffer_error_2 (Current_Language) := To_Unbounded_String ("Composants thread non périodiques : impossible de calculer la borne de l'event data port avec ce jeu de composants thread."); lb_compute_buffer_error_3 (Current_Language) := To_Unbounded_String ("Erreur sur le modèle de composant thread : impossible de calculer la borne de l'event data port avec plusieurs consommateurs. "); lb_maximum_buffer_size (Current_Language) := To_Unbounded_String ("Nombre maximum de message dans l'event data port : "); lb_average_buffer_size (Current_Language) := To_Unbounded_String ("Nombre moyen de message dans l'event data port : "); -- -- Dependencies logic -- lb_precedencies_period_error (Current_Language) := To_Unbounded_String ("Imposible d'ordonnancer avec les contraintes de precedence : les composants thread ayant des contraintes de précédence doivent avoir des périodes harmoniques."); lb_chetto_error2 (Current_Language) := To_Unbounded_String ("Composants thread avec des périodes différentes : impossible d'appliquer la méthode de Chetto/Blazewicz. "); lb_chetto_error3 (Current_Language) := To_Unbounded_String ("Erreur sur le modèle de composant thread : impossible d'appliquer la méthode de Chetto/Blazewicz. "); end if; end if; end initialize; end translate.aadl_labels;