WO2020016511A1 - Procédé d'accéleration de l'exécution d'un programme à chemin unique par exécution en parallèle de séquences conditionnellement concurrentes - Google Patents

Procédé d'accéleration de l'exécution d'un programme à chemin unique par exécution en parallèle de séquences conditionnellement concurrentes Download PDF

Info

Publication number
WO2020016511A1
WO2020016511A1 PCT/FR2019/051768 FR2019051768W WO2020016511A1 WO 2020016511 A1 WO2020016511 A1 WO 2020016511A1 FR 2019051768 W FR2019051768 W FR 2019051768W WO 2020016511 A1 WO2020016511 A1 WO 2020016511A1
Authority
WO
WIPO (PCT)
Prior art keywords
sequence
execution
resource
program
satisfied
Prior art date
Application number
PCT/FR2019/051768
Other languages
English (en)
Inventor
Mathieu JAN
Original Assignee
Commissariat A L'energie Atomique Et Aux Energies Alternatives
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by Commissariat A L'energie Atomique Et Aux Energies Alternatives filed Critical Commissariat A L'energie Atomique Et Aux Energies Alternatives
Priority to US17/260,852 priority Critical patent/US20210271476A1/en
Priority to EP19758795.9A priority patent/EP3807757A1/fr
Publication of WO2020016511A1 publication Critical patent/WO2020016511A1/fr

Links

Classifications

    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/22—Microcontrol or microprogram arrangements
    • G06F9/28—Enhancement of operational speed, e.g. by using several microcontrol devices operating in parallel
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
    • G06F9/38—Concurrent instruction execution, e.g. pipeline or look ahead
    • G06F9/3836—Instruction issuing, e.g. dynamic instruction scheduling or out of order instruction execution
    • G06F9/3851—Instruction issuing, e.g. dynamic instruction scheduling or out of order instruction execution from multiple instruction streams, e.g. multistreaming

Definitions

  • the field of the invention is that of real-time computer systems for which the execution time of tasks, and in particular the execution time in the worst case (called WCET for "Worst Case Execution Time”), must be known to ensure validation and guarantee safety.
  • the invention aims more particularly to improve the accuracy of the estimation of the WCET of a program by making it possible to provide a guaranteed WCET without being too pessimistic.
  • Real-time systems must react reliably, which implies both being certain of the result produced by their programs but also knowing the time they take to execute.
  • the worst-case execution times are therefore fundamental data for the validation and safety of such real-time systems, and even more in the context of autonomous real-time systems (robotics, autonomous car, GPS) for which safety is essential.
  • the code transformation technique called “single-path” (or unique path in French) makes it possible to predict the execution time of a program and therefore to provide a reliable WCET.
  • the different code sequences which must be selectively executed according to the result of a conditional branching coming to examine input data (one can thus also speak of conditionally concurrent sequences or sequences of an alternative because constituting the possible choices of an alternative) are brought into a sequential code, relying on the capacities of certain processors to associate predicates with their assembly instructions to preserve the semantics origin of the program.
  • this “single-path” transformation technique therefore makes it possible to reduce the combinatorial of the possible execution paths of a program by leading to the obtaining of a single execution path.
  • the measurement of a single execution time of the program thus transformed is therefore sufficient to provide the WCET of the program.
  • the measurement process to determine the WCET is thereby simplified because the problem of the coverage rate of a program achieved by a measurement campaign is eliminated.
  • the invention aims to propose a technique for eliminating this increase in WCET execution time. To this end, it proposes a method of executing a program by a computer system having computing resources capable of executing sequences of instructions, comprising a conditional selection of a sequence of instructions from a sequence called satisfied and at least one so-called unsatisfied sequence. This process includes the following steps:
  • the distribution of the execution of the satisfied sequence and of the unsatisfied sequence consists in having the unsatisfied sequence executed by the first calculation resource and the satisfied sequence by the second calculation resource;
  • a data item written in memory by one of the first and of the second computing resource is subject to a visibility restriction for be visible only by that of the first and second computation resources which carried out the writing of the data in memory;
  • each of the first and second computing resources notifies the other of the first and the second computing resources of the termination of the execution of that of the satisfied and non-satisfied sequences which it executes;
  • the continuation of the execution of the program is carried out by the computing resource having executed the sequence of instructions selected by the conditional selection during the parallel execution of the satisfied sequence and the unsatisfied sequence;
  • FIG. 1 illustrates a standard conditional branching structure of the “Test if not” type
  • FIG. 2 illustrates the steps of the method according to the invention of distributing the sequences of an alternative and of their execution in parallel each by a different computing resource
  • FIG. 3 illustrates the steps of the method according to the invention for terminating the execution in parallel of the sequences of an alternative and for continuing the execution of the program by a computing resource.
  • the invention relates to a method for executing a program by a computer system, in particular a real-time system, having computing resources capable of executing sequences of instructions.
  • the computer system is for example a calculation processor, single-core or multi-core.
  • the program can in particular execute tasks, for example real-time tasks, programmed according to the “single-path” programming technique, the method according to the invention making it possible to accelerate the execution of this single-path program.
  • FIG. 1 shows the processing of a standard conditional branching structure present in a program P executed by a computing resource A.
  • This program consists of three sequences of instructions li, l 2 and l 3 .
  • the sequence of instructions li ends with a standard conditional branch instruction, the execution of which causes the evaluation “CS? »Of the satisfaction of a connection condition and the selection, depending on the result of this evaluation, of a sequence of instructions to be executed from the two possible sequences l 2 and I 3 .
  • sequence satisfied l 2 this is the sequence which is executed when the condition is satisfied, "O"
  • sequence not -satisfied l 3 this is the sequence which is executed when the condition is not satisfied, "N").
  • the invention proposes a new type of instruction known as the distribution of conditionally concurrent sequences (or more simply the distribution instruction in the following) which, when executed, achieves, due to the presence of a conditional selection d 'one of the sequences, a distribution of the execution of these different sequences in parallel on different computing resources.
  • the conditional selection can be a selection of the if-then-if type allowing one to come to select one of two possible sequences of an alternative, a satisfied sequence and an unsatisfied sequence.
  • the invention extends to a conditional selection of the switch type (or “switch”) making it possible to come and select a sequence from a plurality of possible sequences (typically at least three possible sequences), a satisfied sequence and at least one non-sequenced sequence. satisfied.
  • switch or “switch”
  • the program P is initially executed by a first calculation resource A and the execution of the sequence of instructions li comprises a conditional selection of a sequence of instructions from a satisfied sequence and at least one unsatisfied sequence.
  • This conditional selection may include the evaluation of the satisfaction of a branching condition and the selection, as a function of the result of this evaluation, of a sequence of instructions to be executed from two possible sequences.
  • the sequence of instructions li ends with a distribution instruction which, when executed by the computing resource A, causes the execution of the satisfied sequence and the unsatisfied sequence to be split between the first resource of calculation A and a second computing resource B of the computer system different from resource A.
  • conditional selection results from the execution, prior to the allocation instruction, of an instruction for testing the satisfaction of the condition.
  • the result of the execution of the test instruction is stored in a part of the status register of the micro-architecture and the distribution instruction comes to use this information to determine the address at which the program continues, c 'is to say the address of the sequence selected by the conditional sequence.
  • conditional selection results from the execution of the allocation instruction itself.
  • the distribution instruction takes as parameters the registers on which the condition must be evaluated and the result of this evaluation is used directly during the execution of the instruction to determine the address at which the program continues, ie the address of the sequence selected by the conditional sequence.
  • the distribution instruction is a branching instruction enriched to designate the second computing resource B.
  • the branching instruction can thus take as argument the second computing resource B, and in this case, it is during the construction of the binary that this information must be produced.
  • the branch instruction can take as argument an specific register (usable_resources register in the example below) to identify the second computing resource B among a set of usable resources.
  • the distribution can consist in having the unsatisfied sequence l 3 executed by the first computing resource A and the satisfied sequence l 2 by the second computing resource B.
  • the choice to deport the satisfied sequence allows, on the first computational resource A executing the unsatisfied sequence, to continue to preload the instructions of the program in a sequential manner and thus to avoid the introduction of any hazards in the execution of the program at the pipeline level. execution of micro-architecture instructions.
  • the distribution includes an RQ offset request. the execution of one of the satisfied and unsatisfied sequences, this request being formulated by the first calculation resource A intended for the second calculation resource B. When this offset request is accepted ACK by the second resource computation B, the program X which was being executed by the second computation resource B is suspended.
  • This suspension is considered as an interruption in the operation of the computing resource B, and the execution context of the program X is then saved.
  • a transfer TS, from resource A to resource B, of the state necessary to begin the execution of that of the satisfied and unsatisfied sequences that resource B must execute is carried out. This transfer concerns the values of the registers handled by the program P before the allocation instruction, the current stack structure of the program P as well as the identification of the computing resource A.
  • the satisfied sequence l 2 and the unsatisfied sequence l 3 are then executed in parallel, each by a computing resource among the first resource A and the second resource B.
  • the program P comprises a fourth sequence of instructions l 4 which must be executed once the parallel execution of the sequences l 2 and U ends.
  • the invention proposes that the instruction sequences U and I 3 each end with a parallelism termination instruction.
  • the sequence of instructions I 3 executed by the computation resource A is the first to be terminated and the execution of the parallelism termination instruction causes the computation resource A to notify TR the resource of calculation B of the termination of the sequence I 3 .
  • the execution of the parallelism termination instruction causes the calculation resource B to notify the calculation resource A of this termination.
  • resource B has executed the sequence l 2 which turns out to be the sequence selected by the selection conditional (the condition was satisfied in this case).
  • the execution of the program P is continued on the calculation resource B by executing the instructions of the instruction block l 4 , after the resource B has requested TE from the resource A to transfer NE from the state of notification registers for updating these locally.
  • the computing resource A can then resume the execution of the program X which was executed on the computing resource B before the parallel execution of the satisfied and not satisfied sequences l 2 and l 3 , by restoring the context d execution of this program since its backup.
  • each of the computing resources A and B calls this instruction for terminating parallelism in order, first of all, to wait for the termination of the other sequence so as to preserve the property of temporal predictability of a program, then , then, to determine at which instruction the execution of the program continues.
  • this parallelism termination instruction has the effect of selecting the computing resource on which the execution of the program will continue as well as of retaining only the data produced by the selected sequence.
  • the distribution and termination instructions proposed by the invention can be generated in a conventional manner by a compiler during the construction of a binary of the program processed.
  • a first strategy can consist in continuing the execution of the program P on the computing resource which has executed the unsatisfied alternative, which can induce a transfer of data from the other computing resource if the sequence selected is the satisfied sequence.
  • another strategy can consist in continuing the execution of the program P on the resource which has executed the selected sequence in order to avoid this transfer of data.
  • each write access creates a new copy of a data item and an identifier of the computing resource owner of this data item is then added to the meta-information associated with the data item. This identifier is thus used to determine whether a computing resource can access this data.
  • This mechanism for restricting the visibility of the data handled by a computing resource makes it possible to privatize a level of the memory hierarchy shared between the computing resources.
  • this piece of data must not be made visible to other programs or, via Inputs / Outputs (I / O), to the external environment of the system executing the programs.
  • Data having among its meta-information an identifier of a computing resource used to implement the parallel execution of a sequence of an alternative cannot then be updated in a memory for this objective or to a E / S. This restriction forces the program developer to implement communications to other programs or to I / O outside the parallel execution of alternative sequences.
  • this mechanism for restricting the visibility of data in the standard operation of a central memory, for example of the DRAM type, the use of this mechanism is limited to the memory hierarchy between computing resources and main memory.
  • a data item written into memory by one of the first A and of the second B computation resource is subject to a visibility restriction so as to be visible only by that of the first and second computation resources which have written the data in memory.
  • the method comprises the termination of the restriction of visibility of the data written in memory by the computing resource from the first and the second calculation resource which executed, during the parallel execution of the satisfied sequence and the unsatisfied sequence, the selected sequence of instructions.
  • These data those of the sequence l 2 executed by the resource B in the example of FIG. 3, are thus made visible to all of the calculation resources.
  • the method comprises, during the continuation of the execution of the program, the invalidation of the data written in memory by the calculation resource from among the first and the second calculation resource which has not executed, during the execution in parallel of the sequence satisfied and the sequence not satisfied, the sequence of instructions selected.
  • the data of the sequence I3 executed by the resource A are thus rendered invalid. It is possible to specify for a given program a maximum authorized number of simultaneous parallel executions of sequences of an alternative. This maximum authorized number cannot be greater than the number of computing resources of the hardware architecture considered.
  • the “single-path” code transformation technique can be applied to alternatives which cannot be the subject of the distribution according to the invention in order to maintain the construction of a single execution path.
  • the sequences selected and not selected by the conditional selection are executed one after the other by the first calculation resource.
  • the method according to the invention makes it possible not to request the conventional branch prediction units since by construction the two sequences of an alternative are executed. No rear transmission for updating the instruction counter at the step of reading the instructions within a microarchitecture is therefore necessary. However, an exploration of the choices of the computing resource to be used to continue the execution of the program after termination of the parallel execution alternative sequences can be performed to, for example, reduce the WCET of the program.
  • a table is associated with each calculation resource and each entry in the table contains a current program identifier P, a maximum authorized number of simultaneous parallel executions EPSmax, an EPSact counter of simultaneous parallel executions (initialized to 0) for this program P and two sets of size equal to the number of computing resources of the hardware architecture.
  • the first set, noted resources_usable indicates the computing resources usable for a parallel execution of the sequences of the alternatives of the program P
  • the second set, noted resources_used indicates the computing resources currently used by this same program P.
  • L ' initialization of usable_resources is the responsibility of a binary development phase, while reused_resources initially contains the computing resource used to start the execution of the program P.
  • An execution without parallelism results in an element size for l 'set resources_used, while an execution with parallelism requires that the size of this same set is greater than 1.
  • Two sets of notification registers also make it possible to indicate, by calculation resource, 1) the first failure of a request for the offset of a sequence of an alternative, the value of the instruction counter upon failure of this request (initially at 0) and the occurrence of subsequent failures, called the additional failure notification field, for example a bit, (initially disabled) and 2) the first attempt to exceed the maximum authorized number EPSmax, the value of the instruction counter during this attempt to pass (initially at 0) and the occurrence of subsequent attempts to pass, called the notification field for additional attempt to pass (initially invalidated).
  • an interrupt mechanism can be used in order to notify a resource for calculating the occurrence of such events. All of this information can be part of the program execution context which must be saved / restored each time the program is preempted / resumed.
  • the meta-information is supplemented by information indicating whether the data is globally visible to all of the resources (noted as global, by default valid), and a identification of the computation resource owner of the data (noted owner, by default invalidated).
  • the distribution instruction is treated as a conventional conditional branch instruction and the present method is not implemented.
  • all the registers of notification of attempt to exceed the maximum authorized number are updated with, if it is the first attempt to exceed (identifiable by an instruction counter value of 0), l address of the dispatch instruction. If this is not the first attempt to overtake, only the additional overtaking attempt notification field is validated. The method then waits for a new distribution instruction to resume step A-1.
  • step A-2 If these values are not identical, a computation resource B usable by this program but not yet used is identified by difference between the sets resources usable and resources resources used. The process then continues in step A-2.
  • the calculation resource A notifies a request for the offset of the execution of one of the sequences among the satisfied sequence and the unsatisfied sequence to the calculation resource B and waits for a response from the latter.
  • a request for execution offset consists of a pair comprising the identifier of the program P and the identifier of the computing resource A.
  • the identifier of the computing resource A issuing the request is verified as being part of the computing resources capable of issuing such a request, namely whether the computing resource A belongs to the resource_use set associated with this program.
  • the computing resource B notifies the rejection of the offset request to the computing resource A issuing the request.
  • All the registers of notification of failure to request an offset from an alternative sequence are updated on the calculation resource A with, if it is the first offset request (identifiable by a instruction counter value at 0), the address of the dispatch instruction. If this is not a first deport attempt, only the additional deport request failure notification field is validated. The process continues in step A-4.
  • the EPSact counter is incremented. Then, the following information is transmitted by the calculation resource A to the calculation resource B: all of the volatile and non-volatile registers handled by the program, the stack pointer, the current stack structure, the identifier of the first calculation resource, the value of the EPSact counter, the connection address specified by the alternative distribution instruction as well as the condition value generating the selection of one of the sequences of the alternative.
  • step A-6 The method continues to execute in step A-6.
  • resource B If the offset request is not accepted by resource B, resource B is removed from the set of usable resources associated with calculation resource A and another calculation resource that can be used but not yet used is identified (in the same way in step A1 of the method) and the method then continues in step A-2 on the computing resource A.
  • Resource B can possibly be added later to the set of usable resources associated with calculation resource A when conditions are met, for example when the application load of resource B is lower or when the system configuration changes and the resource B can be used again.
  • the distribution instruction is then treated as a conventional conditional branch instruction. All the registers of notification of failure of request for offset are however updated with, if it is the first attempt of offset for this program (identifiable by a value of instruction counter at 0) , the address of the alternative allocation instruction. If this is not a first attempt, only the additional offset request failure notification field is validated. The method then waits for a new distribution instruction to resume step A-1.
  • Step A-6 The value of the instruction counter of the computing resource A, issuing a request for offset, is positioned at the next instruction and the execution of the alternative not satisfied continues on the computing resource B, receiving an alternative offset request, to the instruction specified in the allocation instruction.
  • the set of usable resources is updated to include the computing resource B, having accepted the offset request.
  • a new copy of the modified data is inserted into the memory hierarchy and the fields of its global and owner meta-information are respectively invalidated and positioned at the identifier of the computing resource A or B.
  • the updating strategy (whether immediate or deferred) only concerns these caches and therefore excludes an impact on the main memory or on I / O in order to avoid making any data inconsistent with other programs or the external environment available.
  • the mechanism for updating a cache of the last level of the memory hierarchy is deactivated when the global and owner fields are respectively invalidated and positioned at the identifier of a computing resource. This rule for write access can only apply for access to the first shared level of a memory hierarchy, if no material consistency is ensured between the private levels of the memory hierarchy.
  • the request is transmitted to the first level of the memory hierarchy of the other computing resource B used in this level of execution in parallel of sequences of an alternative.
  • a variant is to carry out this transmission in parallel with the transmission of the request to the first level of the memory hierarchy of the computing resource A, however this increases the latency worse case of a memory request from a computing resource.
  • a compromise can be explored to allow such simultaneity during a certain number of hardware cycles and reduce the latency of these memory accesses made by the second computing resource.
  • Another variant is to transmit requests in parallel to all of the first levels of the memory hierarchy of the computing resources used by the program (those identified by the set lives_used).
  • the memory request of a calculation resource A can only consult the data for which the fields of its global and owner meta-information are respectively valid and invalidated (data modified by any other sequence of an alternative) or respectively invalidated and equal to the identifier of the computing resource A (data having been previously modified by the sequence executing on the computing resource A).
  • the process steps are as follows for processing the parallelism termination instruction.
  • the termination information for this alternative is transmitted to the computing resource B involved in parallel execution. If the calculation resource B has not completed the execution of the sequence which has been assigned to it, the calculation resource A then awaits notification of the termination by the calculation resource B.
  • the calculation resource A then inspects the value of the condition evaluation (for example calculated during the execution of the allocation instruction, or else by relying on the state register of the calculation resource) to determine if the sequence that it has just executed corresponds to the sequence selected by the conditional selection.
  • the condition evaluation for example calculated during the execution of the allocation instruction, or else by relying on the state register of the calculation resource
  • the calculation resource A propagates a request to the memory hierarchy to make valid the global field present in the meta-information associated with each data modified during parallel execution, identifiable by the fact that the field owner is set to the identifier of the calculation resource A.
  • the owner field is also invalidated during the processing of this request.
  • the calculation resource A propagates a request to invalidate in a conventional manner the data modified during parallel execution, identifiable by the fact that the owner field is positioned at the identifier of the computing resource A. This last field is also invalidated and the global field is reset. Furthermore, the pipeline is emptied, the memory area used by the stack of resource A is invalidated.
  • the counter ESPmax is decremented and the computation resource which is not selected to continue the execution is removed from the set of resources used.
  • the execution context of the selected sequence (all the volatile and non-volatile registers handled by the program, the pointer to stack, the complete stack structure) must be transferred from the computation resource having executed this selected sequence. Furthermore, the data handled by the program and stored in the private levels of the memory hierarchy associated with the calculation resource having executed the selected sequence must be propagated to the first level shared between the two calculation resources of the memory hierarchy. Whatever the choice of the calculation resource, if the notification registers associated with two calculation resources, used in the parallel execution which ends, notify the first failures of request for offset or attempt to overtake, only the additional notification fields associated with these events are validated on the calculation resource selected to continue program execution. Otherwise, each notification register associated with the calculation resource selected to continue the execution of the program is updated with the information of the other calculation resource used.
  • the value of the instruction counter of the calculation resource retained to continue the execution of the program is positioned at the jump address specified in the parallelism termination instruction.
  • an interruption of end of execution in parallel is notified, this in order to allow for example the resumption of the execution of other programs.
  • step C-3 can be anticipated at step C-2 to possibly reduce the additional cost of this notification by parallelizing its execution with the expectation of the termination of the parallelism. To avoid any inconsistency on the values handled by the other sequences of the alternative, this anticipation must be carried out on data not exploited by these same sequences in the course of execution.
  • the method as previously described comprises a step of measuring the duration of execution of the program and a step of determining a WCET of the program.
  • the invention is not limited to the method as described above but also extends to a computer program product comprising program code instructions, in particular the previously described instructions for distributing sequences and terminating parallelism, which , when the program is executed by a computer, lead the latter to implement this process.

Landscapes

  • Engineering & Computer Science (AREA)
  • Theoretical Computer Science (AREA)
  • Software Systems (AREA)
  • Physics & Mathematics (AREA)
  • General Engineering & Computer Science (AREA)
  • General Physics & Mathematics (AREA)
  • Multimedia (AREA)
  • Devices For Executing Special Programs (AREA)
  • Advance Control (AREA)

Abstract

L'invention porte sur un procédé d'exécution d'un programme (P) par un système informatique disposant de ressources de calcul capables d'exécuter des séquences d'instructions, comprenant une sélection conditionnelle d'une séquence d'instructions parmi une séquence satisfaite (I2) et au moins une séquence non-satisfaite (I3); Il comprend les étapes suivantes : - sur exécution d'une instruction de répartition de séquences par une première ressource de calcul (A), répartition de l'exécution de la séquence satisfaite (I2) et de l'au moins une séquence non-satisfaite (I2) entre la première ressource de calcul (A) et au moins une deuxième ressource de calcul (B); - exécution en parallèle de la séquence satisfaite (I2) et de l'au moins une séquence non-satisfaite (I3) chacune par une ressource de calcul parmi la première (A) et l'au moins une deuxième (B) ressource de calcul; - une fois la séquence satisfaite (I2) et l'au moins une séquence non-satisfaite (I3) intégralement exécutées, poursuite de l'exécution du programme (P) par une ressource de calcul parmi la première et l'au moins une deuxième ressource de calcul.

Description

PROCÉDÉ D'ACCÉLÉRATION DE L'EXÉCUTION D'UN PROGRAMME À CHEMIN UNIQUE PAR EXÉCUTION EN PARALLÈLE DE SÉQUENCES CONDITIONNELLEMENT CONCURRENTES
DESCRIPTION
DOMAINE TECHNIQUE
Le domaine de l'invention est celui des systèmes informatiques temps-réel pour lesquels le temps d'exécution des tâches, et notamment le temps d'exécution dans le pire des cas (dit WCET pour « Worst Case Execution Time »), doit être connu pour en assurer la validation et en garantir la sûreté. L'invention vise plus particulièrement à améliorer la précision de l'estimation du WCET d'un programme en rendant possible la fourniture d'un WCET garanti sans être trop pessimiste.
ÉTAT DE LA TECHNIQUE ANTÉRIEURE
Les systèmes temps-réel doivent réagir de manière fiable, ce qui implique à la fois d'être certain du résultat produit par leurs programmes mais aussi de connaître le temps qu'ils prennent pour s'exécuter. Les temps d'exécution pire-cas sont ainsi des données fondamentales pour la validation et la sûreté de tels systèmes temps-réel, et encore plus dans le contexte des systèmes temps-réels autonomes (robotique, voiture autonome, GPS) pour lesquels la sûreté de fonctionnement est primordiale.
Cependant calculer un WCET, à la fois garanti (majorant strict) et pas trop pessimiste afin de réduire les coûts et la complexité de tels systèmes temps-réels, est un problème difficile à résoudre du fait de l'impact temporel qu'ont les unités matérielles qui exécutent les programmes et du nombre de chemins d'exécution possibles des programmes.
La technique de transformation de code appelé « single-path » (ou chemin unique en français) permet de rendre prédictible le temps d'exécution d'un programme et donc de fournir un WCET fiable. Selon cette technique, les différentes séquences de code qui doivent sélectivement être exécutées selon le résultat d'un branchement conditionnel venant examiner des données d'entrée (on peut ainsi également parler de séquences conditionnellement concurrentes ou encore de séquences d'une alternative car constituant les choix possibles d'une alternative) sont amenées en un code séquentiel, en s'appuyant sur les capacités de certains processeurs à associer des prédicats à leurs instructions assembleur pour conserver la sémantique d'origine du programme.
L'application de cette technique de transformation « single-path » permet donc de réduire la combinatoire des chemins d'exécutions possibles d'un programme en aboutissant à l'obtention d'un seul chemin d'exécution. La mesure d'un unique temps d'exécution du programme ainsi transformé est donc suffisante pour fournir le WCET du programme. La démarche par mesure pour déterminer le WCET s'en trouve simplifiée car le problème du taux de couverture d'un programme atteint par une campagne de mesures est éliminé.
L'utilisation de cette technique de transformation de code « single-path » présente toutefois l'inconvénient d'accroître le temps d'exécution d'un programme puisque les séquences conditionnellement concurrentes d'une alternative sont exécutées de manière séquentielle.
EXPOSÉ DE L'INVENTION
L'invention a pour objectif de proposer une technique permettant d'éliminer cet accroissement du temps d'exécution WCET. Elle propose à cet effet un procédé d'exécution d'un programme par un système informatique disposant de ressources de calcul capables d'exécuter des séquences d'instructions, comprenant une sélection conditionnelle d'une séquence d'instructions parmi une séquence dite satisfaite et au moins une séquence dite non-satisfaite. Ce procédé comprend les étapes suivantes :
- sur exécution d'une instruction de répartition de séquences par une première ressource de calcul du système informatique, répartition de l'exécution de la séquence satisfaite et de l'au moins une séquence non-satisfaite entre la première ressource de calcul et au moins une deuxième ressource de calcul du système informatique ; - exécution en parallèle de la séquence satisfaite et de l'au moins une séquence non-satisfaite chacune par une ressource de calcul parmi la première et l'au moins une deuxième ressource de calcul ;
- une fois la séquence satisfaite et l'au moins une séquence non-satisfaite intégralement exécutées, poursuite de l'exécution du programme par une ressource de calcul parmi la première et l'au moins une deuxième ressource de calcul.
Ainsi, lorsqu'un programme exécuté sur une ressource de calcul A atteint une instruction de répartition de séquences d'instructions, l'une des séquences satisfaite et non-satisfaite est exécutée sur une autre ressource de calcul B tandis que l'autre des séquences satisfaite et non-satisfaite est exécutée sur la ressource de calcul A. Cette exécution en parallèle permet de réduire le WCET du programme. Le procédé selon l'invention permet donc de dégager du temps processeur supplémentaire pour, soit exécuter des programmes supplémentaires sur une même architecture matérielle, soit permettre de sélectionner une architecture matérielle moins performante mais plus économique pour exécuter un ensemble de programmes donné. Ce procédé permet donc d'optimiser l'utilisation des ressources de calcul lors de la conception d'un système temps réel nécessitant la détermination de WCET.
Certains aspects préférés mais non limitatifs de ce procédé sont les suivants :
- la répartition de l'exécution de la séquence satisfaite et de la séquence non- satisfaite consiste à faire exécuter la séquence non-satisfaite par la première ressource de calcul et la séquence satisfaite par la deuxième ressource de calcul ;
- lors de l'exécution en parallèle de la séquence satisfaite et de la séquence non- satisfaite, une donnée écrite en mémoire par l'une de la première et de la deuxième ressource de calcul fait l'objet d'une restriction de visibilité pour n'être visible que par celle de la première et de la deuxième ressource de calcul qui a réalisé l'écriture de la donnée en mémoire ;
- il comprend, lors de la poursuite de l'exécution du programme, la terminaison de la restriction de visibilité des données écrites en mémoire par la ressource de calcul parmi la première et la deuxième ressource de calcul qui a exécuté, lors de l'exécution en parallèle de la séquence satisfaite et de la séquence non-satisfaite, la séquence d'instructions sélectionnée ;
- il comprend, lors de la poursuite de l'exécution du programme, l'invalidation des données écrites en mémoire par la ressource de calcul parmi la première et la deuxième ressource de calcul qui n'a pas exécuté, lors de l'exécution en parallèle de la séquence satisfaite et de la séquence non-satisfaite, la séquence d'instructions sélectionnée ;
- chacune des première et deuxième ressources de calcul notifie à l'autre des première et la deuxième ressources de calcul de la terminaison de l'exécution de celle des séquences satisfaite et non-satisfaite qu'elle exécute ;
- la poursuite de l'exécution du programme est réalisée par la ressource de calcul ayant exécuté la séquence d'instructions sélectionnée par la sélection conditionnelle lors de l'exécution en parallèle de la séquence satisfaite et de la séquence non- satisfaite ;
- lorsque qu'un nombre maximal autorisé d'exécutions en parallèle simultanées de séquences est atteint, la répartition de l'exécution de la séquence satisfaite et de l'au moins une séquence non-satisfaite entre la première ressource de calcul et l'au moins une deuxième ressource de calcul du système informatique n'est pas réalisée et la séquence sélectionnée par la sélection conditionnelle est exécutée par la première ressource de calcul ;
- lorsque que le nombre maximal autorisé d'exécutions en parallèle simultanées de séquences est atteint, les séquences sélectionnée et non sélectionnée par la sélection conditionnelle sont exécutées l'une après l'autre par la première ressource de calcul ;
- il comprend en outre une étape de mesure de la durée d'exécution du programme et une étape de détermination d'un temps d'exécution dans le pire des cas du programme. BRÈVE DESCRIPTION DES DESSINS
D'autres aspects, buts, avantages et caractéristiques de l'invention apparaîtront mieux à la lecture de la description détaillée suivante de formes de réalisation préférées de celle-ci, donnée à titre d'exemple non limitatif, et faite en référence aux dessins annexés sur lesquels :
la figure 1 illustre une structure de branchement conditionnelle standard du type « Test si sinon » ;
la figure 2 illustre les étapes du procédé selon l'invention de répartition des séquences d'une alternative et de leur exécution en parallèle chacune par une ressource de calcul différente ;
la figure 3 illustre les étapes du procédé selon l'invention de terminaison de l'exécution en parallèle des séquences d'une alternative et de poursuite de l'exécution du programme par une ressource de calcul.
EXPOSÉ DÉTAILLÉ DE MODES DE RÉALISATION PARTICULIERS
L'invention porte sur un procédé d'exécution d'un programme par un système informatique, notamment un système temps-réel, disposant de ressources de calcul capables d'exécuter des séquences d'instructions. Le système informatique est par exemple un processeur de calcul, mono-cœur ou multi-cœur. Le programme peut notamment exécuter des tâches, par exemple des tâches temps réel, programmées selon la technique de programmation « single-path », le procédé selon l'invention permettant d'accélérer l'exécution de ce programme à chemin unique.
On a représenté sur la figure 1 le traitement d'une structure de branchement conditionnelle standard présente au sein d'un programme P exécuté par une ressource de calcul A. Ce programme est constitué de trois séquences d'instructions li, l2 et l3. La séquence d'instructions li se termine par une instruction de branchement conditionnelle standard dont l'exécution provoque l'évaluation « CS ? » de la satisfaction d'une condition de branchement et la sélection, en fonction du résultat de cette évaluation, d'une séquence d'instructions à exécuter parmi les deux séquences possibles l2 et I3. Ces deux séquences possibles sont conditionnellement concurrentes (une seule est exécutée, sélectionnée en fonction du résultat de l'évaluation de la satisfaction de la condition) et sont dénommées par la suite séquence satisfaite l2 (il s'agit de la séquence qui est exécutée lorsque la condition est satisfaite, « O ») et séquence non-satisfaite l3 (il s'agit de la séquence qui est exécutée lorsque la condition est non-satisfaite, « N »).
L'invention propose un nouveau type d'instruction dite de répartition de séquences conditionnellement concurrentes (ou plus simplement instruction de répartition dans ce qui suit) qui, lorsqu'elle est exécutée, réalise, du fait de la présence d'une sélection conditionnelle d'une des séquences, une répartition de l'exécution de ces différentes séquences en parallèle sur différentes ressources de calcul.
La sélection conditionnelle peut être une sélection du type si-alors-sinon permettant de venir sélectionner l'une de deux séquences possibles d'une alternative, une séquence satisfaite et une séquence non-satisfaite. L'invention s'étend à une sélection conditionnelle de type aiguillage (ou « switch ») permettant de venir sélectionner une séquence parmi une pluralité de séquences possibles (typiquement au moins trois séquences possibles), une séquence satisfaite et au moins une séquence non- satisfaite. On prend dans ce qui suit l'exemple d'une sélection de type si-alors-sinon, étant entendu qu'une sélection de type aiguillage peut aisément se ramener à cet exemple en venant la remplacer par une série de sélections de type si-alors-sinon en cascade.
Comme représenté sur la figure 2, le programme P est initialement exécuté par une première ressource de calcul A et l'exécution de la séquence d'instructions li comprend une sélection conditionnelle d'une séquence d'instructions parmi une séquence satisfaite et au moins une séquence non-satisfaite. Cette sélection conditionnelle peut comprendre l'évaluation de la satisfaction d'une condition de branchement et la sélection, en fonction du résultat de cette évaluation, d'une séquence d'instructions à exécuter parmi deux séquences possibles.
La séquence d'instructions li se termine par une instruction de répartition qui, lorsqu'elle est exécutée par la ressource de calcul A, entraîne la répartition de l'exécution de la séquence satisfaite et de la séquence non-satisfaite entre la première ressource de calcul A et une deuxième ressource de calcul B du système informatique différente de la ressource A.
Dans un mode de réalisation possible, la sélection conditionnelle résulte de l'exécution, préalablement à l'instruction de répartition, d'une instruction de test de la satisfaction de la condition. Le résultat de l'exécution de l'instruction de test est stocké dans une partie de registre d'état de la micro-architecture et l'instruction de répartition vient exploiter cette information pour déterminer l'adresse à laquelle le programme se poursuit, c'est-à-dire l'adresse de la séquence sélectionnée par la séquence conditionnelle.
Dans un autre mode de réalisation possible, la sélection conditionnelle résulte de l'exécution de l'instruction de répartition elle-même. L'instruction de répartition prend en paramètres les registres sur lesquels la condition doit être évaluée et le résultat de cette évaluation est exploité directement lors de l'exécution de l'instruction pour déterminer l'adresse à laquelle le programme se poursuit, i.e. l'adresse de la séquence sélectionnée par la séquence conditionnelle.
Dans chacun de ces modes de réalisation, l'instruction de répartition est une instruction de branchement enrichie pour désigner la deuxième ressource de calcul B. L'instruction de branchement peut ainsi prendre en argument la deuxième ressource de calcul B, et dans ce cas, c'est lors de la construction du binaire que cette information doit être produite. Alternativement, l'instruction de branchement peut prendre en argument un registre spécifique (registre ressources_utilisables dans l'exemple ci-après) pour identifier la deuxième ressource de calcul B parmi un ensemble de ressources utilisables.
Comme représenté en figure 2, la répartition peut consister à faire exécuter la séquence non-satisfaite l3 par la première ressource de calcul A et la séquence satisfaite l2 par la deuxième ressource de calcul B. Le choix de déporter la séquence satisfaite permet, sur la première ressource de calcul A exécutant la séquence non-satisfaite, de continuer à précharger les instructions du programme d'une manière séquentielle et ainsi d'éviter l'introduction de tout aléas dans l'exécution du programme au niveau du pipeline d'exécution d'instructions d'une micro-architecture. La répartition comprend une demande de déport RQ. de l'exécution de l'une des séquences satisfaite et non-satisfaite, cette demande étant formulée par la première ressource de calcul A à destination de la deuxième ressource de calcul B. Lorsque cette demande de déport est acceptée ACK par la deuxième ressource de calcul B, le programme X qui était en train d'être exécuté par la deuxième ressource de calcul B est suspendu. Cette suspension est considérée comme une interruption dans le fonctionnement de la ressource de calcul B, et le contexte d'exécution du programme X est alors sauvegardé. Un transfert TS, de la ressource A à la ressource B, de l'état nécessaire pour entamer l'exécution de celle des séquences satisfaite et non-satisfaite que le ressource B doit exécuter est réalisé. Ce transfert concerne les valeurs des registres manipulés par le programme P avant l'instruction de répartition, la structure de pile courante du programme P ainsi que l'identification de la ressource de calcul A.
La séquence satisfaite l2 et la séquence non-satisfaite l3 sont alors exécutées en parallèle, chacune par une ressource de calcul parmi la première ressource A et la deuxième ressource B.
Une fois ces deux séquences l2 et I3 intégralement exécutées, l'exécution du programme P se poursuit sur une ressource de calcul parmi la première ressource A et la deuxième ressource B.
Plus particulièrement, comme représenté sur la figure 3, le programme P comprend une quatrième séquence d'instructions l4 qui doit s'exécuter une fois que l'exécution en parallèle des séquences l2 et U se termine.
L'invention propose que les séquences d'instructions U et I3 se terminent chacune par une instruction de terminaison de parallélisme. Dans l'exemple représenté, la séquence d'instructions I3 exécutée par la ressource de calcul A est la première à se terminer et l'exécution de l'instruction de terminaison de parallélisme fait que la ressource de calcul A notifie TR la ressource de calcul B de la terminaison de la séquence I3. Lorsque la séquence d'instructions U exécutée par la ressource de calcul B se termine, l'exécution de l'instruction de terminaison de parallélisme fait que la ressource de calcul B notifie la ressource de calcul A de cette terminaison. Dans cet exemple, la ressource B a exécuté la séquence l2 qui s'avère être la séquence sélectionnée par la sélection conditionnelle (la condition était en l'occurrence satisfaite). Dans cet exemple, l'exécution du programme P est poursuivie sur la ressource de calcul B en exécutant les instructions du bloc d'instructions l4, après que la ressource B ait demandé TE à la ressource A le transfert NE de l'état de registres de notification pour la mise à jour de ceux-ci localement.
La ressource de calcul A peut alors reprendre alors l'exécution du programme X qui s'exécutait sur la ressource de calcul B avant l'exécution en parallèle des séquences satisfaite et non-satisfaite l2 et l3, en venant restaurer le contexte d'exécution de ce programme depuis sa sauvegarde.
Ainsi, chacune des ressources de calcul A et B fait appel à cette instruction de terminaison de parallélisme afin, tout d'abord, d'attendre la terminaison de l'autre séquence pour ainsi conserver la propriété de prédictibilité temporelle d'un programme, puis, ensuite, de déterminer à quelle instruction l'exécution du programme se poursuit. Par ailleurs, cette instruction de terminaison de parallélisme a pour effet de sélectionner la ressource de calcul sur laquelle l'exécution du programme va se poursuivre ainsi que de conserver uniquement les données produites par la séquence sélectionnée.
Les instructions de répartition et de terminaison proposées par l'invention peuvent être générées de manière classique par un compilateur lors de la construction d'un binaire du programme traité.
On relèvera qu'il est nécessaire de réaliser l'ensemble des accès mémoires des séquences l2, 13 de l'alternative pour garantir la prédictibilité temporelle de l'exécution du programme. En effet, la connaissance de la séquence sélectionnée par la sélection conditionnelle ne peut pas être utilisée pour éliminer les accès mémoires de la séquence non-sélectionnée car cela engendrait des variations dans le temps d'exécution des alternatives.
On a vu que l'exécution du programme P peut se poursuivre sur l'une ou l'autre des ressources de calcul A et B utilisées dans l'exécution en parallèle des séquences satisfaite et non-satisfaite. Une première stratégie peut consister à poursuivre l'exécution du programme P sur la ressource de calcul qui a exécuté l'alternative non-satisfaite, ce qui peut induire un transfert de données depuis l'autre ressource de calcul si la séquence sélectionnée est la séquence satisfaite. Comme représenté sur la figure 3, une autre stratégie peut consister à poursuivre l'exécution du programme P sur la ressource qui a exécutée la séquence sélectionnée afin d'éviter ce transfert de données.
On notera que si un programme (comme le programme X sur les figures 2 et 3) a été interrompu pour permettre l'exécution en parallèle des séquences satisfaite et non satisfaite, le contexte d'exécution de ce programme doit être restauré afin de permettre la poursuite de son exécution. Si la poursuite de l'exécution de ce programme se poursuit sur la même ressource ce calcul, cette restauration peut être réalisée dès lors que la séquence, parmi les séquences satisfaite et non satisfaite, exécutée par cette ressource de calcule se termine. Cette restauration peut également être réalisée à la terminaison du parallélisme, voire ultérieurement. Et comme on l'a vu précédemment, cette restauration peut éventuellement être réalisée sur l'autre ressource de calcul impliquée dans l'exécution en parallèle.
Lors de l'exécution en parallèle des séquences satisfaite et non-satisfaite l2 et l3, un fonctionnement spécifique de la hiérarchie mémoire stockant des données manipulées par un programme est nécessaire. En effet, une même donnée peut être manipulée par les deux séquences l2 et I3. Mais si des accès en lecture ne posent pas de problème, des accès en écriture soulèvent le problème de la cohérence de ces données. Ainsi, les accès en écriture depuis une ressource de calcul exécutant l'une des séquences de l'alternative ne doivent pas être visibles depuis la ressource de calcul exécutant l'autre séquence de l'alternative.
Pour ce faire, chaque accès en écriture crée une nouvelle copie d'une donnée et un identifiant de la ressource de calcul propriétaire de cette donnée est alors ajouté aux méta-informations associées à la donnée. Cet identifiant est ainsi utilisé pour déterminer si une ressource de calcul peut accéder à cette donnée. Ce mécanisme de restriction de la visibilité des données manipulées par une ressource de calcul permet de privatiser un niveau de la hiérarchie mémoire partagé entre les ressources de calcul.
Par ailleurs, outre le besoin d'isoler les copies d'une donnée manipulée par les différentes ressources exécutant en parallèle les différentes séquences d'une alternative, cette donnée ne doit pas être rendue visible à d'autres programmes ou, via des Entrées/Sorties (E/S), à l'environnement externe du système exécutant les programmes. Une donnée ayant parmi ses méta-informations un identifiant d'une ressource de calcul utilisée pour mettre en œuvre l'exécution en parallèle d'une séquence d'une alternative ne peut alors être mise à jour dans une mémoire pour cet objectif ou vers une E/S. Cette restriction contraint le développeur de programmes à implémenter les communications vers d'autres programmes ou vers des E/S en-dehors de l'exécution en parallèle de séquences d'une alternative.
D'une manière optionnelle, afin de limiter l'intrusion de ce mécanisme de restriction de la visibilité des données dans le fonctionnement standard d'une mémoire centrale, par exemple de type DRAM, l'utilisation de ce mécanisme se limite à la hiérarchie mémoire entre les ressources de calcul et la mémoire centrale.
Ainsi selon le procédé de l'invention, lors de l'exécution en parallèle de la séquence satisfaite l2 et de la séquence non-satisfaite l3, une donnée écrite en mémoire par l'une de la première A et de la deuxième B ressource de calcul fait l'objet d'une restriction de visibilité pour n'être visible que par celle de la première et de la deuxième ressource de calcul qui a réalisé l'écriture de la donnée en mémoire.
Par ailleurs, lors de la poursuite de l'exécution du programme après la terminaison de l'exécution en parallèle des séquences de l'alternative, le procédé comprend la terminaison de la restriction de visibilité des données écrites en mémoire par la ressource de calcul parmi la première et la deuxième ressource de calcul qui a exécuté, lors de l'exécution en parallèle de la séquence satisfaite et de la séquence non- satisfaite, la séquence d'instructions sélectionnée. Ces données, celles de la séquence l2 exécutée par la ressource B dans l'exemple de la figure 3, sont ainsi rendues visibles à l'ensemble des ressources de calcul.
Et a contrario, le procédé comprend lors de la poursuite de l'exécution du programme, l'invalidation des données écrites en mémoire par la ressource de calcul parmi la première et la deuxième ressource de calcul qui n'a pas exécuté, lors de l'exécution en parallèle de la séquence satisfaite et de la séquence non-satisfaite, la séquence d'instructions sélectionnée. Dans l'exemple de la figure 3, les données de la séquence I3 exécutée par la ressource A sont ainsi rendues invalides. Il est possible de spécifier pour un programme donné un nombre maximal autorisé d'exécutions en parallèle simultanées de séquences d'une alternative. Ce nombre maximal autorisé ne peut être supérieur au nombre de ressource de calcul de l'architecture matérielle considérée.
Lorsque ce nombre maximal autorisé est atteint, les séquences d'une alternative ne peuvent plus faire l'objet d'une exécution en parallèle et des instructions de branchement conditionnel standards (cf. figure 1) doivent être utilisées. Si cette utilisation est faite lors de la génération du code assembleur d'un programme par un compilateur, alors le binaire généré du programme est dépendant de ce nombre maximal autorisé. Si cette utilisation est faite à l'exécution par le matériel par substitution aux instructions de répartition de séquences d'une alternative, alors le binaire généré est indépendant du degré de parallélisme d'alternative maximal.
Si ce nombre maximal autorisé est trop faible pour couvrir toutes les alternatives du programme, celui-ci est alors constitué de plusieurs chemins d'exécution. Un compromis est donc à trouver entre l'utilisation des ressources de calcul et la complexité d'une analyse WCET qui est en partie liée au nombre de chemins d'un programme.
Dans une variante de réalisation, lorsque le programme atteint son nombre maximal autorisé d'exécutions en parallèle simultanées de séquences d'une alternative, la technique de transformation de code « single-path » peut être appliquée aux alternatives ne pouvant faire l'objet de la répartition selon l'invention afin de maintenir la construction d'un unique chemin d'exécution. Dans un tel cas de figures, les séquences sélectionnée et non sélectionnée par la sélection conditionnelle sont exécutées l'une après l'autre par la première ressource de calcul.
Le procédé selon l'invention permet de ne pas solliciter les unités classiques de prédiction de branchement puisque par construction les deux séquences d'une alternative sont exécutées. Aucune transmission arrière pour la mise à jour du compteur d'instruction à l'étape de lecture des instructions au sein d'une microarchitecture n'est donc nécessaire. Toutefois, une exploration des choix de la ressource de calcul à utiliser pour poursuivre l'exécution du programme après terminaison de l'exécution en parallèle de séquences d'une alternative peut être réalisée pour, par exemple, réduire le WCET du programme.
On décrit dans ce qui suit une implémentation possible du procédé selon l'invention.
Une table est associée à chaque ressource de calcul et chaque entrée de la table contient un identifiant de programme actuel P, un nombre maximal autorisé d'exécutions en parallèle simultanées EPSmax, un compteur EPSact d'exécutions en parallèle simultanées (initialisé à 0) pour ce programme P et deux ensembles de taille égale au nombre de ressources de calcul de l'architecture matérielle.
Le premier ensemble, noté ressources_utilisables, indique les ressources de calcul utilisables pour une exécution en parallèle des séquences des alternatives du programme P, tandis que le second ensemble, noté ressources_utilisees, indique les ressources de calcul actuellement utilisées par ce même programme P. L'initialisation de ressources_utilisables est du ressort d'une phase d'élaboration du binaire, tandis que ressources_utilisees contient initialement la ressource de calcul utilisée pour démarrer l'exécution du programme P. Une exécution sans parallélisme se traduit par une taille d'un élément pour l'ensemble ressources_utilisees, alors qu'une exécution avec parallélisme nécessite que la taille de ce même ensemble soit supérieur à 1.
Deux ensembles de registres de notification permettent par ailleurs d'indiquer, par ressource de calcul, 1) le premier échec d'une demande de déport d'une séquence d'une alternative, la valeur du compteur d'instruction lors de l'échec de cette demande (initialement à 0) et l'occurrence d'échecs ultérieurs, appelé champ de notification d'échecs supplémentaires, par exemple un bit, (initialement invalidé) et 2) la première tentative de dépassement du nombre maximal autorisé EPSmax, la valeur du compteur d'instruction lors de cette tentative de dépassement (initialement à 0) et l'occurrence de tentatives de dépassement ultérieures, appelé champ de notification de tentative de dépassement supplémentaire (initialement invalidé). D'une manière optionnelle, un mécanisme d'interruption peut être utilisé afin de notifier une ressource de calcul de l'occurrence de tels évènements. L'ensemble de ces informations peuvent faire partie du contexte d'exécution du programme qu'il faut sauvegarder/restaurer à chaque préemption/reprise d'exécution du programme.
A chaque unité élémentaire de stockage de données dans une hiérarchie mémoire, mémoire centrale exclue, les méta-informations sont complétées par une information indiquant si la donnée est globalement visible par l'ensemble des ressources (noté globale, par défaut valide), et une identification de la ressource de calcul propriétaire de la donnée (noté propriétaire, par défaut invalidé). Ces deux éléments permettent de mettre en œuvre le mécanisme de restriction de la visibilité des données manipulées durant une exécution en parallèle des séquences d'une alternative.
Les étapes du procédé sont alors les suivantes pour le traitement d'une instruction de répartition de séquences d'une alternative.
Etape A-l
Lorsqu'une instruction de répartition de séquences d'une alternative d'un programme est décodée par une première ressource de calcul A, la valeur du compteur EPSact est comparée au nombre maximal autorisé EPSmax.
Si ces valeurs sont identiques, l'instruction de répartition est traitée comme instruction de branchement conditionnelle classique et le présent procédé n'est pas mis en œuvre. L'ensemble des registres de notification de tentative de dépassement du nombre maximal autorisé sont en revanche mis à jour avec, s'il s'agit de la première tentative de dépassement (identifiable par une valeur de compteur d'instruction à 0), l'adresse de l'instruction de répartition. S'il ne s'agit pas d'une première tentative de dépassement, seul le champ de notification de tentative de dépassement supplémentaire est validé. Le procédé attend alors une nouvelle instruction de répartition pour reprendre l'étape A-l.
Si ces valeurs ne sont pas identiques, une ressource de calcul B utilisable par ce programme mais non encore utilisée est identifiée par différence entre les ensembles ressources_utilisables et ressources_utilisees. Le procédé se poursuit alors à l'étape A-2.
Si aucune ressource de calcul n'est identifiée, le procédé se poursuit à l'étape A-
5. Etape A-2
La ressource de calcul A notifie une demande de déport de l'exécution de l'une des séquences parmi la séquence satisfaite et la séquence non-satisfaite à la ressource de calcul B et attend une réponse de cette dernière. Une demande de déport de l'exécution consiste en un couple comprenant l'identifiant du programme P et l'identifiant de la ressource de calcul A.
Lorsque la demande de déport est reçue par la ressource de calcul B, l'identifiant de la ressource de calcul A émettrice de la demande est vérifié comme faisant partie des ressources de calcul pouvant émettre une telle demande, à savoir si la ressource de calcul A appartient à l'ensemble ressources_utilisees associé à ce programme.
Si c'est le cas, le procédé se poursuit alors à l'étape A-3.
Si ce n'est pas le cas, la ressource de calcul B notifie le rejet de la demande de déport à la ressource de calcul A émettrice de la demande. L'ensemble des registres de notification d'échec de demande de déport d'une séquence d'une alternative sont mis à jour sur la ressource de calcul A avec, s'il s'agit de la première demande de déport (identifiable par une valeur de compteur d'instruction à 0), l'adresse de l'instruction de répartition. S'il ne s'agit pas d'une première tentative de déport, seul le champ de notification d'échec de demande de déport supplémentaire est validé. Le procédé se poursuit à l'étape A-4.
Etape A-3
Si cette demande de déport est acceptée, côté ressource de calcul A émettrice de la demande de déport, le compteur EPSact est incrémenté. Puis, les informations suivantes sont transmises par la ressource de calcul A vers la ressource de calcul B : l'ensemble des registres volatils et non-volatils manipulés par le programme, le pointeur de pile, la structure de pile courante, l'identifiant de la première ressource de calcul, la valeur du compteur EPSact, l'adresse de branchement spécifiée par l'instruction de répartition d'alternative ainsi que la valeur de condition générant la sélection de l'une des séquences de l'alternative. Ces transferts peuvent être mis en œuvre de différentes manières selon la microarchitecture sous-jacente, par exemple en totalité par le matériel après l'exécution d'une barrière mémoire et des extensions matérielles adéquates ou via des instructions permettant d'accéder aux registres de la ressource de calcul A depuis la ressource de calcul B ou encore purement via des instructions classiques d'accès à la mémoire pour transférer ces informations.
L'ensemble de ces valeurs sont positionnées sur la ressource de calcul B réceptrice de la demande de déport, tandis que les registres non manipulés par le programme sont réinitialisés sur cette même ressource de calcul B.
Le procédé poursuit son exécution à l'étape A-6.
Etape A-4
Si la demande de déport n'est pas acceptée par la ressource B, la ressource B est retirée de l'ensemble ressources_utilisables associé à la ressource de calcul A et une autre ressource de calcul utilisable mais non encore utilisée est identifiée (de la même manière qu'à l'étape A-l du procédé) et le procédé se poursuit alors à l'étape A-2 sur la ressource de calcul A.
La ressource B peut éventuellement être ultérieurement ajoutée à l'ensemble ressources_utilisables associé à la ressource de calcul A lorsque des conditions sont réunies, par exemple lorsque la charge applicative de la ressource B est plus faible ou lorsque la configuration du système change et que la ressource B peut de nouveau être utilisée.
Etape A-5
Si aucune ressource de calcul n'est identifiée, l'exécution du programme se poursuit sans utiliser le procédé selon l'invention. L'instruction de répartition est alors traitée comme une instruction de branchement conditionnelle classique. L'ensemble des registres de notification d'échec de demande de déport sont en revanche mis à jour avec, s'il s'agit de la première tentative de déport pour ce programme (identifiable par une valeur de compteur d'instruction à 0), l'adresse de l'instruction de répartition d'alternative. S'il ne s'agit pas d'une première tentative, seul le champ de notification d'échec de demande de déport supplémentaire est validé. Le procédé attend alors une nouvelle instruction de répartition pour reprendre l'étape A-l.
Etape A-6 La valeur du compteur d'instruction de la ressource de calcul A, émettrice d'une demande de déport, est positionné à l'instruction suivante et l'exécution de l'alternative non-satisfaite se poursuit sur la ressource de calcul B, réceptrice d'une demande de déport d'alternative, à l'instruction spécifiée dans l'instruction de répartition.
Sur chacune des deux ressources de calcul, l'ensemble ressources_utilisables est mis à jour pour inclure la ressource de calcul B, ayant acceptée la demande de déport.
Les étapes du procédé sont les suivantes durant l'exécution en parallèle des séquences de l'alternative (identifiable par le fait que le compteur EPSact présente une valeur supérieure à 1). En dehors de ces étapes, aucune donnée manipulée ne peut avoir son champ propriétaire valide.
Etape B-l
Pour chaque exécution d'une instruction générant depuis une ressource de calcul A ou B un accès mémoire en écriture, une nouvelle copie de la donnée modifiée est insérée dans la hiérarchie mémoire et les champs de ses méta-informations globale et propriétaire sont respectivement invalidé et positionné à l'identifiant de la ressource de calcul A ou B. Lorsque la hiérarchie mémoire s'appuie sur des caches, la stratégie de mise à jour (qu'elle soit immédiate ou différée) concerne uniquement ces caches et exclue donc un impact sur la mémoire centrale ou sur des E/S afin d'éviter toute mise à disposition de données incohérentes à d'autres programmes ou à l'environnement externe. Pour ce faire, le mécanisme de mise à jour d'un cache du dernier niveau de la hiérarchie mémoire est désactivé lorsque les champs globale et propriétaire sont respectivement invalidé et positionné à l'identifiant d'une ressource de calcul. Cette règle pour un accès en écriture peut s'appliquer uniquement pour un accès au premier niveau partagé d'une hiérarchie mémoire, si aucune cohérence matérielle n'est assurée entre les niveaux privés de la hiérarchie mémoire.
Etape B-2
Pour chaque exécution d'une instruction générant un accès mémoire en lecture au premier niveau de la hiérarchie mémoire d'une ressource de calcul A, et avant toute transmission de la requête au niveau supérieur de la hiérarchie mémoire de la ressource de calcul A, la requête est transmise au premier niveau de la hiérarchie mémoire de l'autre ressource de calcul B utilisée dans ce niveau d'exécution en parallèle de séquences d'une alternative.
Une variante est de réaliser cette transmission en parallèle avec la transmission de la requête au premier niveau de la hiérarchie mémoire de la ressource de calcul A, toutefois ceci augmente la latence pire cas d'une requête mémoire depuis une ressource de calcul. Un compromis peut être exploré pour autoriser une telle simultanéité pendant un certain nombre de cycles matériels et réduire la latence de ces accès mémoire réalisés par la seconde ressource de calcul.
Une autre variante est de transmettre en parallèle des requêtes à l'ensemble des premiers niveaux de la hiérarchie mémoire des ressources de calcul utilisées par le programme (celles identifiées par l'ensemble ressources_utilisees).
L'ensemble de ces variantes sont applicables pour passer d'un niveau n à un niveau n+1 d'une hiérarchie mémoire. La requête mémoire d'une ressource de calcul A ne peut que consulter les données dont les champs de ses méta-informations globale et propriétaire sont respectivement valide et invalidé (donnée modifiée par aucune autre séquence d'une alternative) ou respectivement invalidé et égal à l'identifiant de la ressource de calcul A (donnée ayant été préalablement modifiée par la séquence s'exécutant sur la ressource de calcul A).
Les étapes du procédé sont les suivantes pour le traitement de l'instruction de terminaison de parallélisme.
Etape C-l
Lorsqu'une instruction de terminaison d'alternative est décodée par une ressource de calcul A, l'information de terminaison de cette alternative est transmise à la ressource de calcul B impliquée dans l'exécution en parallèle. Si la ressource de calcul B n'a pas terminée l'exécution de la séquence qui lui a été assignée, la ressource de calcul A attend alors la notification de la terminaison par la ressource de calcul B.
Etape C-2
La ressource de calcul A inspecte alors la valeur de l'évaluation de la condition (par exemple calculée lors de l'exécution de l'instruction de répartition, ou encore en s'appuyant sur le registre d'état de la ressource de calcul) pour déterminer si la séquence qu'elle vient d'exécuter correspond à la séquence sélectionnée par la sélection conditionnelle.
Si c'est le cas, la ressource de calcul A propage une requête à la hiérarchie mémoire pour rendre valide le champ globale présent dans les méta-informations associées à chaque donnée modifiée durant l'exécution en parallèle, identifiables par le fait que le champ propriétaire est positionné à l'identifiant de la ressource de calcul A. Le champ propriétaire est également invalidé lors du traitement de cette requête.
Si ce n'est pas le cas, la ressource de calcul A propage une requête pour invalider d'une manière classique les données modifiées durant l'exécution en parallèle, identifiables par le fait que le champ propriétaire est positionné à l'identifiant de la ressource de calcul A. Ce dernier champ est également invalidé et le champ globale est réinitialisé. Par ailleurs, le pipeline est vidé, la zone mémoire utilisée par la pile de la ressource A est invalidée.
Etape C-3
Sur chaque ressource de calcul, le compteur ESPmax est décrémenté et la ressource de calcul qui n'est pas retenue pour poursuivre l'exécution est retirée de l'ensemble ressources_ u tilisees .
Si la ressource de calcul choisie pour poursuivre l'exécution du programme n'a pas exécuté la séquence sélectionnée, le contexte d'exécution de la séquence sélectionnée (l'ensemble des registres volatils et non-volatils manipulés par le programme, le pointeur de pile, la structure de pile complète) doit être transféré depuis la ressource de calcul ayant exécutée cette séquence sélectionnée. Par ailleurs, les données manipulées par le programme et stockées dans les niveaux privés de la hiérarchie mémoire associée à la ressource de calcul ayant exécutée la séquence sélectionnée doivent être propagés jusqu'au premier niveau partagé entre les deux ressources de calcul de la hiérarchie mémoire. Quel que soit le choix de la ressource de calcul, si les registres de notification associés à deux ressources de calcul, utilisées dans l'exécution en parallèle qui se termine, notifient des premiers échecs de demande de déport ou de tentative de dépassement, seuls les champs de notification supplémentaires associés à ces évènements sont validés sur la ressource de calcul retenue pour poursuivre l'exécution du programme. Sinon, chaque registre de notification associé à la ressource de calcul retenue pour poursuivre l'exécution du programme est mise à jour avec les informations de l'autre ressource de calcul utilisée.
Enfin, la valeur du compteur d'instruction de la ressource de calcul retenue pour poursuivre l'exécution du programme est positionnée à l'adresse de saut spécifiée dans l'instruction de terminaison de parallélisme. Sur la ressource de calcul n'ayant pas été retenue pour poursuivre l'exécution du programme, une interruption de fin d'exécution en parallèle est notifiée, ceci afin de permettre par exemple la reprise de l'exécution d'autres programmes.
Il est à noter que cette étape C-3 peut être anticipée à l'étape C-2 pour éventuellement réduire le surcoût de cette notification en venant paralléliser son exécution avec l'attente de la terminaison du parallélisme. Pour éviter toute incohérence sur les valeurs manipulées par les autres séquences de l'alternative, cette anticipation doit être menée sur des données non exploitées par ces mêmes séquences en cours d'exécution.
Le procédé tel que précédemment décrit comprend une étape de mesure de la durée d'exécution du programme et une étape de détermination d'un WCET du programme. L'invention n'est pas limitée au procédé tel que précédemment décrit mais s'étend également à un produit programme d'ordinateur comprenant des instructions de code de programme, notamment les instructions précédemment décrites de répartition de séquences et de terminaison de parallélisme, qui, lorsque le programme est exécuté par un ordinateur, conduisent celui-ci à mettre en œuvre ce procédé.

Claims

REVENDICATIONS
1. Procédé d'exécution d'un programme (P) par un système informatique disposant de ressources de calcul capables d'exécuter des séquences d'instructions, comprenant une sélection conditionnelle d'une séquence d'instructions parmi une séquence dite satisfaite (l2) et au moins une séquence dite non-satisfaite (l3), le procédé étant caractérisé en ce qu'il comprend les étapes suivantes :
- sur exécution d'une instruction de répartition de séquences par une première ressource de calcul (A) du système informatique, répartition de l'exécution de la séquence satisfaite (l2) et de l'au moins une séquence non-satisfaite (l2) entre la première ressource de calcul (A) et au moins une deuxième ressource de calcul (B) du système informatique ;
- exécution en parallèle de la séquence satisfaite (l2) et de l'au moins une séquence non-satisfaite (I3) chacune par une ressource de calcul parmi la première (A) et l'au moins une deuxième (B) ressource de calcul ;
- une fois la séquence satisfaite (l2) et l'au moins une séquence non-satisfaite (I3) intégralement exécutées, poursuite de l'exécution du programme (P) par une ressource de calcul parmi la première et l'au moins une deuxième ressource de calcul.
2. Procédé selon la revendication 1, dans lequel la répartition de l'exécution de la séquence satisfaite et de la séquence non-satisfaite consiste à faire exécuter la séquence non-satisfaite (I3) par la première ressource de calcul (A) et la séquence satisfaite (l2) par la deuxième ressource de calcul (B).
3. Procédé selon l'une des revendications 1 et 2 dans lequel, lors de l'exécution en parallèle de la séquence satisfaite et de la séquence non-satisfaite, une donnée écrite en mémoire par l'une de la première et de la deuxième ressource de calcul fait l'objet d'une restriction de visibilité pour n'être visible que par celle de la première et de la deuxième ressource de calcul qui a réalisé l'écriture de la donnée en mémoire.
4. Procédé selon la revendication 3 comprenant, lors de la poursuite de l'exécution du programme, la terminaison de la restriction de visibilité des données écrites en mémoire par la ressource de calcul parmi la première et la deuxième ressource de calcul qui a exécuté, lors de l'exécution en parallèle de la séquence satisfaite et de la séquence non-satisfaite, la séquence d'instructions sélectionnée.
5. Procédé selon la revendication 3 comprenant, lors de la poursuite de l'exécution du programme, l'invalidation des données écrites en mémoire par la ressource de calcul parmi la première et la deuxième ressource de calcul qui n'a pas exécuté, lors de l'exécution en parallèle de la séquence satisfaite et de la séquence non-satisfaite, la séquence d'instructions sélectionnée.
6. Procédé selon l'une des revendications 1 à 5, dans lequel chacune des première et deuxième ressources de calcul notifie (TR, TE) à l'autre des première et la deuxième ressources de calcul de la terminaison de l'exécution de celle des séquences satisfaite et non-satisfaite qu'elle exécute.
7. Procédé selon l'une des revendications 1 à 6, dans lequel la poursuite de l'exécution du programme est réalisée par la ressource de calcul (B) ayant exécuté la séquence d'instructions sélectionnée (l2) par la sélection conditionnelle lors de l'exécution en parallèle de la séquence satisfaite et de la séquence non-satisfaite.
8. Procédé selon l'une des revendications 1 à 7, dans lequel lorsque qu'un nombre maximal autorisé d'exécutions en parallèle simultanées de séquences est atteint, la répartition de l'exécution de la séquence satisfaite (l2) et de l'au moins une séquence non-satisfaite (l2) entre la première ressource de calcul (A) et l'au moins une deuxième ressource de calcul (B) du système informatique n'est pas réalisée et la séquence sélectionnée par la sélection conditionnelle est exécutée par la première ressource de calcul.
9. Procédé selon la revendication 8 dans lequel, lorsque que le nombre maximal autorisé d'exécutions en parallèle simultanées de séquences est atteint, les séquences sélectionnée et non sélectionnée par la sélection conditionnelle sont exécutées l'une après l'autre par la première ressource de calcul.
10. Procédé selon l'une des revendications 1 à 9, comprenant en outre une étape de mesure de la durée d'exécution du programme et une étape de détermination d'un temps d'exécution dans le pire des cas du programme.
11. Produit programme d'ordinateur comprenant des instructions de code de programme qui, lorsque le programme est exécuté par un ordinateur, conduisent celui-ci à mettre en œuvre le procédé selon l'une des revendications 1 à 10.
PCT/FR2019/051768 2018-07-18 2019-07-15 Procédé d'accéleration de l'exécution d'un programme à chemin unique par exécution en parallèle de séquences conditionnellement concurrentes WO2020016511A1 (fr)

Priority Applications (2)

Application Number Priority Date Filing Date Title
US17/260,852 US20210271476A1 (en) 2018-07-18 2019-07-15 Method for accelerating the execution of a single-path program by the parallel execution of conditionally concurrent sequences
EP19758795.9A EP3807757A1 (fr) 2018-07-18 2019-07-15 Procédé d'accéleration de l'exécution d'un programme à chemin unique par exécution en parallèle de séquences conditionnellement concurrentes

Applications Claiming Priority (2)

Application Number Priority Date Filing Date Title
FR1856659 2018-07-18
FR1856659A FR3084187B1 (fr) 2018-07-18 2018-07-18 Procede d'acceleration de l'execution d'un programme a chemin unique par execution en parallele de sequences conditionnellement concurrentes

Publications (1)

Publication Number Publication Date
WO2020016511A1 true WO2020016511A1 (fr) 2020-01-23

Family

ID=65031459

Family Applications (1)

Application Number Title Priority Date Filing Date
PCT/FR2019/051768 WO2020016511A1 (fr) 2018-07-18 2019-07-15 Procédé d'accéleration de l'exécution d'un programme à chemin unique par exécution en parallèle de séquences conditionnellement concurrentes

Country Status (4)

Country Link
US (1) US20210271476A1 (fr)
EP (1) EP3807757A1 (fr)
FR (1) FR3084187B1 (fr)
WO (1) WO2020016511A1 (fr)

Citations (2)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US20140215187A1 (en) * 2013-01-29 2014-07-31 Advanced Micro Devices, Inc. Solution to divergent branches in a simd core using hardware pointers
US20160196112A1 (en) * 2013-08-02 2016-07-07 Somnium Technologies Limited Software Development Tool

Family Cites Families (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
FR3004274A1 (fr) * 2013-04-09 2014-10-10 Krono Safe Procede d'execution de taches dans un systeme temps-reel critique

Patent Citations (2)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US20140215187A1 (en) * 2013-01-29 2014-07-31 Advanced Micro Devices, Inc. Solution to divergent branches in a simd core using hardware pointers
US20160196112A1 (en) * 2013-08-02 2016-07-07 Somnium Technologies Limited Software Development Tool

Also Published As

Publication number Publication date
EP3807757A1 (fr) 2021-04-21
FR3084187B1 (fr) 2021-01-01
US20210271476A1 (en) 2021-09-02
FR3084187A1 (fr) 2020-01-24

Similar Documents

Publication Publication Date Title
EP3129874B1 (fr) Systeme de calcul distribue mettant en oeuvre une memoire transactionnelle materielle de type non-speculatif et son procede d'utilisation pour le calcul distribue
US8539486B2 (en) Transactional block conflict resolution based on the determination of executing threads in parallel or in serial mode
FR2792087A1 (fr) Procede d'amelioration des performances d'un systeme multiprocesseur comprenant une file d'attente de travaux et architecture de systeme pour la mise en oeuvre du procede
EP1337919B1 (fr) Procede de securisation rendant deterministe l'execution en temps reel d'applications multitaches du type controle-commande avec confinement d'erreur
FR2881239A1 (fr) Procede de gestion d'acces a des ressources partagees dans un environnement multi-processeurs
FR2950714A1 (fr) Systeme et procede de gestion de l'execution entrelacee de fils d'instructions
FR2881246A1 (fr) Procede perdictif de gestion, de journalisation ou de rejeu d'operations non deterministes au sein du deroulement d'un processus applicatif
FR2881242A1 (fr) Procede non intrusif de journalisation d'evements internes au sein d'un processus applicatif, et systeme mettant en oeuvre ce procede
FR2882449A1 (fr) Procede non intrusif de rejeu d'evenements internes au sein d'un processus applicatif, et systeme mettant en oeuvre ce procede
US20030135720A1 (en) Method and system using hardware assistance for instruction tracing with secondary set of interruption resources
TW201227520A (en) Virtual machine branching and parallel execution
EP3286647A1 (fr) Placement d'une tâche de calcul sur un processeur fonctionnellement asymetrique
EP3295293B1 (fr) Opérations d'écriture concurrentes sans verrou à fil sécurisé destinées à être utilisées avec une journalisation en ligne multifil
EP0637798B1 (fr) Procédé d'analyse d'interblocage dans un système d'exploitation
FR2881306A1 (fr) Procede de journalisation non intrusive d'evenements externes aupres d'un processus applicatif, et systeme mettant en oeuvre ce procede
FR2881247A1 (fr) Procede de gestion semantique, de journalisation ou de rejeu d'operations non deterministes au sein du deroulement d'un processus applicatif
CA2348069A1 (fr) Systeme et methode de gestion d'une architecture multi-ressources
EP1960934B1 (fr) Procede pour securiser l'execution d'un code logiciel en langage intermediaire dans un appareil portatif
FR2881308A1 (fr) Procede d'acceleration de la transmission de donnees de journalisation en environnement multi ordinateurs et systeme utilisant ce procede
EP2498184A1 (fr) Dispositif pour l'amélioration de la tolérance aux fautes d'un processeur
US7644396B2 (en) Optimal program execution replay and breakpoints
US20150160945A1 (en) Allocation of load instruction(s) to a queue buffer in a processor system based on prediction of an instruction pipeline hazard
EP3807757A1 (fr) Procédé d'accéleration de l'exécution d'un programme à chemin unique par exécution en parallèle de séquences conditionnellement concurrentes
FR2801693A1 (fr) Procedes et appareils pour detecter la presence eventuelle d'exceptions
WO2012038000A1 (fr) Procede de gestion de taches dans un microprocesseur ou un ensemble de microprocesseurs

Legal Events

Date Code Title Description
121 Ep: the epo has been informed by wipo that ep was designated in this application

Ref document number: 19758795

Country of ref document: EP

Kind code of ref document: A1

NENP Non-entry into the national phase

Ref country code: DE

ENP Entry into the national phase

Ref document number: 2019758795

Country of ref document: EP

Effective date: 20210112