WO2012045941A1 - Systeme d'ordonnancement de l'exécution de taches cadence par un temps logique vectoriel - Google Patents

Systeme d'ordonnancement de l'exécution de taches cadence par un temps logique vectoriel Download PDF

Info

Publication number
WO2012045941A1
WO2012045941A1 PCT/FR2011/052175 FR2011052175W WO2012045941A1 WO 2012045941 A1 WO2012045941 A1 WO 2012045941A1 FR 2011052175 W FR2011052175 W FR 2011052175W WO 2012045941 A1 WO2012045941 A1 WO 2012045941A1
Authority
WO
WIPO (PCT)
Prior art keywords
task
vector
tasks
occurrence
vectors
Prior art date
Application number
PCT/FR2011/052175
Other languages
English (en)
Inventor
Renaud Sirdey
Vincent David
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 EP11771244.8A priority Critical patent/EP2625609A1/fr
Priority to JP2013532242A priority patent/JP2013539143A/ja
Priority to US13/824,429 priority patent/US20130247058A1/en
Publication of WO2012045941A1 publication Critical patent/WO2012045941A1/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/46—Multiprogramming arrangements
    • 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/46—Multiprogramming arrangements
    • G06F9/48—Program initiating; Program switching, e.g. by interrupt
    • G06F9/4806—Task transfer initiation or dispatching
    • G06F9/4843—Task transfer initiation or dispatching by program, e.g. task dispatcher, supervisor, operating system
    • G06F9/4881—Scheduling strategies for dispatcher, e.g. round robin, multi-level priority queues

Definitions

  • the invention relates to the scheduling of the execution of interrelated tasks in a multi-tasking system, particularly in the context of the execution of tasks of a data flow process that may include control dependent on the data.
  • a recurring problem in multi-tasking systems is the scheduling of tasks, that is, the execution of each task at a time when all the conditions required by the task are met. These conditions include the availability of data consumed by the task and the availability of space to receive the data produced by the task, in the case of data stream type processing.
  • a method of executing several interdependent tasks on a multi-tasking system comprising the steps of: associating with each task a logical time vector indicative of the dependencies of the task with respect to a set of tasks. other tasks, and to define a partial order relation on the set of logical time vectors, so that a successor task which depends on the execution of an occurrence of a predecessor task has a vector greater than that the predecessor task; perform the task except if its vector is greater than the vector of any of the other tasks; and update the vector of a completed task to reflect the dependencies of a new occurrence of the completed task.
  • the method comprises the following steps: associating with each task a dependency counter indicative of the number of conditions to be satisfied in order to execute an occurrence of the task; when a task is completed, decrement the dependency counter of each task having a vector greater than that of the completed task; update the vector of the completed task to reflect the dependencies of a new occurrence of the task; incrementing the dependency counter of the completed task for each task whose vector is less than that of the completed task; and incrementing the dependency counter of each task having a vector greater than that of the completed task.
  • the logical time vector of a current task comprises a component associated with each possible task. The component associated with the current task contains the instance number of the current task. A component associated with another task identifies the occurrence of that other task that must be completed before the current task can be executed, a null component indicating that the current task does not depend on the task associated with the null component.
  • a processor module is provided with a module for comparing two Nm bit data, comprising a comparison output indicative of an order relationship between the two data, said output being defined by a table comprising rows associated with the consecutive possible values of the first data item and columns associated with the consecutive possible values of the second data item, where each row comprises a state 1 at the intersection with the column associated with the same value followed by a series of states 0.
  • the series of states 0 is followed by a series of states 1 completing the row in a circular manner, the number of states 0 being the same for each row and less than half of the maximum value of the data.
  • a comparator of two vectors in a partial order relationship wherein each vector comprises components having a number of bits multiple of Nm, comprises a plurality of comparison modules of the aforementioned type, connected in a chain by carry propagation terminals ; a gate disposed between the retaining propagation terminals of two consecutive modules, capable of interrupting the carry propagation between said consecutive modules in response to an active state of a signal determining a boundary between components; and a gate disposed at the comparison output, adapted to inhibit the taking into account of the state of this output in response to an inactive state of the boundary determination signal.
  • each module comprises a equality output indicative of the equality of the data presented to the module
  • the comparator comprises logic intended to establish an active indication if and only if all the comparison outputs of the modules are active and the equality output of at least one module is inactive.
  • FIG. Basic example of a sequence of tasks to be performed in a data stream process is a graph showing the dependencies between different occurrences of each task of Figure 1;
  • FIG. 3 corresponds to the graph of FIG. 2, where each occurrence of a task is numbered by a logical time vector used to identify the dependencies between occurrences of the tasks;
  • FIG. 4 shows the graph of FIG. 3 with different execution times for certain task occurrences; Fig.
  • FIG. 5 shows an example of a succession of tasks in a data flow type process, with two alternative execution tasks;
  • Figure 6 is a graph numbered by logical time vectors of the occurrences of the tasks of Figure 5;
  • FIG. 7 is a graph representing an exemplary execution trace of a processing corresponding to FIG. 5, numbered by logical time vectors and dependency counter values;
  • FIG. 8 represents a graph of another execution trace case; and
  • FIG. 9 schematically represents a vector comparator embodiment according to a partial order.
  • task means a generic set of treatments.
  • execution of the task, or an “occurrence” of the task, is meant the execution of the task on a specific set of data (in a data stream type processing, consecutive occurrences of the same task on consecutive datasets of an incoming stream).
  • Logical time vectors are associated with each task and reflect the dependencies of the current occurrence of the task.
  • Logical time vectors associated with a partial order relationship, have been used to date events passed from one process to another, so that each process that receives events by distinct ways can reorder them causally.
  • a logical time vector is normally used to identify and relatively date an event that occurred in the past.
  • logical time vectors are used in the present application to determine from what moment a task can be executed.
  • logical time vectors are used to constrain the order of task execution, that is, to organize events in the future.
  • FIG. 1 represents an elementary flow-type processing.
  • a task A provides data to a task B, which processes it and delivers the result to a task C.
  • the tasks communicate their data via buffers (FIFO), whose depth is 3 in this example.
  • FIFO buffers
  • the conditions for performing these tasks are as follows.
  • Task A can only run if the first buffer is not full.
  • Task B can only execute if the first buffer is not empty and the second buffer is not full.
  • Task C can only execute if the second buffer is not empty.
  • FIG. 2 is a graph showing the dependencies between the occurrences of the tasks A, B and C.
  • the rows correspond respectively to the tasks A, B and C.
  • the consecutive circles in a row correspond to consecutive occurrences of the same task, numbered in FIG. circles.
  • the columns correspond to consecutive execution cycles, assuming, for simplicity, that each occurrence of a task ends in one cycle.
  • Arrows connect dependent occurrences. Each arrow means “must take place before”. In other words, in the graph as shown, each arrow must point to the right; it can not point to the left or be vertical.
  • the arrows in solid lines correspond to dependencies imposed by the order of execution of the tasks.
  • the dashed arrows correspond to the dependencies imposed by the (limited) depth of the buffers.
  • FIG. 3 represents the graph of FIG. 2 where each occurrence of a task is annotated by a logical time vector according to the method referred to herein.
  • a logical time vector is associated with each task, and updated at the end of each occurrence of the task. As the updates of these vectors correspond to incrementations, these vectors can also be called "logical clocks", denoted H.
  • each vector or clock H comprises a component associated with each executable task on a multi-tasking system.
  • An example of such a technique is described in the article [P. A. S. Ward, "An offline algorithm for dimensional-bound analysis," Proceeding of the 1999 IEEE International Conference on Parallel Processing, pp. 128-136.
  • FIG. 3 there are three vectors H (A), H (B) and H (C) respectively assigned to the tasks A, B and C, and each vector has three components respectively assigned to the tasks A, B and vs.
  • a component h. associated with a task Ti of a vector H (Tj) associated with a task Tj contains, for example, the occurrence of the task Ti necessary for the execution of the current occurrence of the task Tj.
  • the component hj associated with the task Tj contains the occurrence of the task Tj that is running.
  • a null component indicates that the current occurrence of the task associated with the vector does not depend on the task associated with the null component.
  • the first component of the vector H (A), corresponding to task A contains 7, which is the current occurrence of task A .
  • this occurrence of the task a requires that the first buffer memory ( Figure 1) has at least one location, that is to say, the 4 th instance of the task B has consumed a given in this buffer; the component (the 2 e ) associated with the task B in the vector H (A) contains 4.
  • the 4 th occurrence of the task B requires that the second buffer memory have at least one location, that is, say that the 1 st occurrence of the task C has consumed data in this buffer; the component (the 3 e ) associated with the task C in the vector H (A) contains 1.
  • Each vector is constructed from the graph by following the arrows of the occurrence to the nearest occurrence of each of the other tasks.
  • the vector H (B) at time t7 contains (6, 6, 3)
  • the vector H (C) contains (5, 5, 5). If there is no such arrow to follow backwards, the component is zero, which is the case for the first occurrences of the tasks A and B.
  • the construction of the vectors proves simple to realize at the execution of an application implementing the tasks. We see that it is sufficient, starting from a certain occurrence (here the sixth for task A, the third for task B, and the first for task C), to systematically increment each component to each execution of the associated task.
  • the initial and update conditions of the vector H (A) in FIG. 3 can be defined as follows:
  • X ⁇ Y is true if and only if: whatever i is between 0 and n, there is and exists between 0 and n such that xj ⁇ yj.
  • Figure 4 shows the graph of Figure 3 modified to represent a case closer to reality.
  • the first two occurrences of task B last twice as long as the other occurrences.
  • the first occurrence of task C starts with a delay cycle
  • the second occurrence of task C starts with two delay cycles
  • the fifth occurrence of task A starts with a delay cycle.
  • the logical time vector of a task remains constant over the number of cycles required for the execution of the associated task, which is seen for the first two occurrences of task B.
  • a vector is updated at the moment where the task ends.
  • the new value of the vector is in effect as soon as the associated task ends, and invariant during the waiting time for a new occurrence of the task (this is also the case during the waiting time for the execution of the first occurrence of tasks B and C).
  • the graph can thus extend to infinity, and thus accommodate occurrences of any duration with any delay. This ensures the absence of interlocking.
  • the logical time vectors are updated by systematic incrementation of their components.
  • a refolding mechanism based on a partial order relation adapted to a subset of the natural numbers is preferably provided.
  • the components of the vectors are defined modulo M, and the partial order relation between two vectors X (xo, X2, ... x n ) and Y (yo, yi, ... y n ) is defined such that :
  • M and S are integers such that 2S ⁇ M, and M is greater than the maximum distance between components of a vector.
  • the maximum difference is 6, for the vector H (A) from the seventh occurrence. This maximum difference is determinable from the moment when all the initial conditions have been taken into account, that is to say from the moment when we begin to increment all the components of all the vectors.
  • the comparison of the components by the relation "less than” defined above is such that a value x is smaller than each of the next 3 (S) values, and greater than each of the previous 4 (M - S -1) values on the circle.
  • S next 3
  • M previous 4
  • the logical time vector of each task is compared to each of the vectors of the other tasks, to know if the task can be executed. This represents significant computation resources if the number of tasks is important: the number of comparisons increases quadratically with the number of tasks.
  • the result of the comparisons indicates that a task can be executed, it is possible that the task can not be executed immediately given the available computing resources (it will be said that the task is executable). It is therefore necessary to manage a list of executable tasks.
  • K a dependency counter
  • the content of the counter is equal to the number of conditions remaining to be satisfied; when the content becomes null, the task becomes executable.
  • the scheduling process observes the contents of the dependency counters and starts the execution of each task whose counter is zero, or schedules the execution of these tasks if the resources do not allow to start their execution in parallel. .
  • the vector H (T) is updated for the new occurrence of the task T.
  • this can be done by incrementing each component of the vector as soon as the number of occurrences reaches a defined threshold value for the component in the initial conditions.
  • K (T): K (T) + 1. In other words, all the conditions required for the execution of the new occurrence of the task T are identified, and they are counted in the dependency counter of the task T.
  • K (Ta): K (Ta) + 1.
  • the new conditions created by the new occurrence of the task T are identified for the other tasks Ta, and are counted in the dependency counters of these other tasks.
  • the dependency counters can be made in hardware form and monitored in parallel by a zero content detection circuit.
  • Logical time vectors can also be stored in dedicated registers, connected to comparators in hardware form, connected to increment and decrement the counters according to the aforementioned rules. (Of course, enough hardware counters and vector registers are provided to satisfy the number of separate tasks expected in the applications that are to be run on the system.) In this case, the system software (the scheduling process ) is only responsible for updating the vectors in the dedicated registers, the comparisons and updates of the counters being performed by hardware acceleration.
  • Dependency counters provide an indication of impending execution, so they can be used, for example, to drive preload operations. In addition, it can be seen that the number of comparisons increases linearly according to the number of tasks.
  • FIG. 5 shows a more complex example of a succession of tasks in a data flow type process with two execution tasks alternative.
  • the task B of FIG. 1 here comprises two tasks, B and B ', of which only one is chosen for execution when the task A ends.
  • Each data produced by an occurrence of the task A is pointed by a selection element SEL towards one of the tasks B and B '.
  • the selection is performed by a CTL control data item, also produced by the task A, and stacked in a FIFO memory of the same depth as the FIFOs placed between the tasks A, B and C.
  • This CTL control data is taken into account.
  • a merge element MRG which chooses the output of the task B or B 'active to transmit it to the task C.
  • FIG. 6 is a dependency graph corresponding to the case of FIG. 5, represented in the hypothesis simplified where the occurrences of tasks have the same duration and do not have a delay (like the graph of Figure 3).
  • the values of the logical time vectors within the nodes representing the occurrences have been noted.
  • the vectors here have four components.
  • the folded vector notation was used with modulo 8 defined components.
  • FIG. 5 represents an exemplary trace of execution of a processing according to the graph of FIG. 6.
  • the nodes in solid line correspond to occurrences executed or running tasks.
  • the dotted nodes correspond to occurrences that are pending execution.
  • the first of these occurrences starts the first occurrence of task B that takes three cycles to complete. From the point of view of its vector and its dependency counter, it is considered that the first occurrence of the task B 'advances at the same time as the first occurrence of the task B.
  • the fourth occurrence of task A, the second occurrence of task B / B ', actually B', and the first occurrence of task C can start in the fifth cycle.
  • the counter K of the task C at the fifth cycle is decremented by 2, by twice applying the first step of updating the counters, once for task B, and once for task B '.
  • the fourth occurrence of task A lasts 6 cycles, the second occurrence of task B 'lasts one cycle, and the first occurrence of task C lasts two cycles.
  • the eighth cycle while the fourth occurrence of task A is still in progress, it was possible to complete the third occurrence of task B / B '(actually B) and start the second occurrence of task C.
  • the fourth task B / B 'occurrence (actually B') must wait for the eleventh cycle, when the fourth occurrence of task A has ended.
  • FIG. 8 is a trace of a simple example of execution of two tasks A and B where this fourth step is useful.
  • the same representation conventions are used as in Figure 7.
  • Each occurrence of a task A produces three data, each of which is consumed by a separate occurrence of task B.
  • the FIFO between the tasks A and B has a depth of three data - it follows that each occurrence of the task A fills the FIFO memory at once.
  • a second occurrence of the task A can start only after the third occurrence of the task B, which finishes freeing the FIFO.
  • the second component of the vector H (A) is incremented by 3 at each execution of an occurrence of the task A, since the start of an occurrence of the task A is subordinated to the execution of three consecutive occurrences of task B.
  • the first component of the vector H (B) is incremented only after each third execution of an occurrence of task B. This indicates that three consecutive occurrences of task B are subordinate to the same occurrence of Task A.
  • N-1 logical time vector comparisons are made, where N is the number of tasks, and each comparison consists of comparing two by two at most N components. of vectors. The number of component comparisons increases quadratically with the number of tasks.
  • FIG. 9 represents the first repetitive elements of an embodiment of a comparator of HA and HB logic time vectors that can satisfy these needs.
  • a logical time vector is defined on a bounded number Nv of bits, for example 64, and that each component of this vector can be defined on a programmable number of bits, multiple of a minimum number Nm, for example 4.
  • This number Nm determines the maximum number of components of a vector.
  • the comparator of FIG. 9 comprises a series of comparison modules 10 connected to the chain. Each module 10 processes 4 bits of two components to compare two HA and HB vectors.
  • a module 10 may be related, from the point of view of its external terminals, to a comparator based on a subtractor performing the sum of its input A and the complement to 2 ( ⁇ B + 1) of its input B.
  • the modules 10 are conventional comparators.
  • the logic table of these modules will be adapted to perform the comparison of folded values.
  • the modules 10 are chained by their retaining outlets and their retaining inputs Co and Ci, so as to construct a comparator of two 64-bit data.
  • the boundaries between the components of the vectors are defined using AND gates 12, a gate 12 being disposed between each retaining output Co of a module and the retaining input Ci of the following module.
  • the holding input of the first module receives 0 (no holdback to take into account).
  • Each gate 12 is controlled by a respective signal S (S0, S1, S2 7) whose active state (1) determines a boundary between components.
  • the active state of the signal S blocks the gate 12, whereby the retention of the module 10 is not transmitted to the next module, and the following module does not propagate the comparison - this next module performs an independent comparison .
  • An inactive signal S (0) makes the gate 12 pass and causes the chaining of two modules 10 by allowing the propagation of restraint. These two modules are thus associated with the same component.
  • the four S signals are inactive, the four modules 10 are associated with a single component of 16 bits. If the signals S1 and S3 are active, the modules are associated with two separate components of 8 bits. If all the signals S are active, each module is associated with a distinct component of 4 bits.
  • each signal S is applied to an inverting input of an OR gate 14, receiving on a second input the output GE of the corresponding module 10. When the signal S is inactive, the gate 14 does not propagate the output GE of the module - it is an intermediate comparison result which must not be taken into account.
  • the inverted E outputs of the modules 10 arrive on an OR gate 18.
  • the output of the gate 18 becomes active if at least one of the outputs E is inactive, that is to say if there is an inequality for at least one pair of components of HA and HB vectors
  • this gate 20 provides an active signal (HA> HB) if all the components of the vector HA are greater than or equal to their respective components of the vector HB (active gate 16 ), and that at least two respective components of the vectors HA and HB are unequal (therefore one strictly greater than the other).
  • active gate 16 active gate 16
  • each module 10 compare folded components.
  • the table below provides, in the context of an example of aliasing, the values of the output GE according to all the possible values of A and B, indicated in decimal.
  • n modules 10 are chained to correspond to a 4n bits component, despite the fact that each module 10 works independently on 4 bits, and therefore on values bounded at 15, all the chained modules, by transmission of reservoirs, work on values of 4n bits, limited to 2 4n - 1.
  • a first set of components is compared.
  • the output of the gate 20 is ignored and the states of the outputs of the gates 16 and 18 are stored for the next cycle, for example in flip-flops.
  • the OR gate 18 receives as an additional input the state previously stored for its output. Thus, if an inequality has been detected in the previous cycle, this detection is imposed on the current cycle. Furthermore, an additional AND gate 22 is interposed between the gates 16 and 20. The output of this gate 22 is active only if the output of the gate 16 and the previously stored state of this output are both active.
  • the output of the gate 20 will be taken into account after a sufficient number of cycles to process all the components using the comparator.

Landscapes

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

Abstract

L'invention concerne un procédé d'exécution de plusieurs tâches interdépendantes sur un système multi-tâches, comprenant les étapes suivantes: associer à chaque tâche (T) un vecteur de temps logique (H) indicatif des dépendances de la tâche par rapport à un ensemble d'autres tâches(Ta),et définir une relation d'ordre partiel sur l'ensemble des vecteurs de temps logique, de manière qu'une tâche successeur qui dépend de l'exécution d'une occurrence d'une tâche prédécesseur ait un vecteur supérieur à celui de la tâche prédécesseur; exécuter la tâche (T) excepté si son vecteur est supérieur au vecteur de l'une quelconque des autres tâches (Ta); et mettre à jour le vecteur d'une tâche terminée (T) pour refléter les dépendances d'une nouvelle occurrence de la tâche terminée.

Description

SYSTEME D'ORDONNANCEMENT DE L'EXECUTION DE TACHES CADENCE PAR UN
TEMPS LOGIQUE VECTORIEL
Domaine technique de l'invention L'invention est relative à l'ordonnancement de l'exécution de tâches interdépendantes dans un système multi-tâches, notamment dans le cadre de l'exécution de tâches d'un processus flot de données pouvant inclure du contrôle dépendant des données.
État de la technique Un problème récurrent dans les systèmes multi-tâches est l'ordonnancement des tâches, c'est-à-dire l'exécution de chaque tâche à un moment où toutes les conditions requises par la tâche sont réunies. Ces conditions sont notamment la disponibilité de données consommées par la tâche et la disponibilité d'un espace pour recevoir les données produites par la tâche, dans le cas d'un traitement de type flot de données.
Il existe diverses méthodes d'ordonnancement de tâches, par exemple basées sur la construction et le parcours de graphes. Certaines méthodes visent l'optimisation des performances, tandis que d'autres visent la sûreté de fonctionnement. Les méthodes visant la sûreté de fonctionnement tentent de réduire, voire supprimer, la possibilité d'inter-blocage (« deadlock » en anglais), survenant, par exemple, dans une situation où deux tâches ne peuvent s'exécuter car la méthode employée détermine que l'exécution de chacune de ces tâches dépend de l'exécution de l'autre tâche.
La demande de brevet US2008-0005357 décrit une méthode applicable aux traitements de type flot de données, visant l'optimisation des performances. La méthode est basée sur la construction de graphes et de circulation de jetons. Une tâche ne peut s'exécuter que si elle dispose d'un jeton produit par une autre tâche. Lorsque la tâche est exécutée, le jeton est transmis à la tâche suivante. Il s'agit d'une transcription assez directe d'un modèle de calcul qui ne permet pas de tenir compte de contraintes offrant des garanties de sûreté de fonctionnement. Résumé de l'invention
On a donc besoin d'une méthode d'ordonnancement offrant à la fois des bonnes performances et une sûreté de fonctionnement.
On tend à satisfaire ce besoin en prévoyant un procédé d'exécution de plusieurs tâches interdépendantes sur un système multi-tâches, comprenant les étapes suivantes : associer à chaque tâche un vecteur de temps logique indicatif des dépendances de la tâche par rapport à un ensemble d'autres tâches, et définir une relation d'ordre partiel sur l'ensemble des vecteurs de temps logique, de manière qu'une tâche successeur qui dépend de l'exécution d'une occurrence d'une tâche prédécesseur ait un vecteur supérieur à celui de la tâche prédécesseur ; exécuter la tâche excepté si son vecteur est supérieur au vecteur de l'une quelconque des autres tâches ; et mettre à jour le vecteur d'une tâche terminée pour refléter les dépendances d'une nouvelle occurrence de la tâche terminée. Selon un mode de mise en œuvre, le procédé comprend les étapes suivantes : associer à chaque tâche un compteur de dépendances indicatif du nombre de conditions à satisfaire pour exécuter une occurrence de la tâche ; lorsqu'une tâche est terminée, décrémenter le compteur de dépendances de chaque tâche ayant un vecteur supérieur à celui de la tâche terminée ; mettre à jour le vecteur de la tâche terminée pour refléter les dépendances d'une nouvelle occurrence de la tâche ; incrémenter le compteur de dépendances de la tâche terminée pour chaque tâche dont le vecteur est inférieur à celui de la tâche terminée ; et incrémenter le compteur de dépendances de chaque tâche ayant un vecteur supérieur à celui de la tâche terminée. Selon un mode de mise en œuvre, le vecteur de temps logique d'une tâche courante comprend une composante associée à chaque tâche possible. La composante associée à la tâche courante contient le numéro d'occurrence de la tâche courante. Une composante associée à une autre tâche identifie l'occurrence de cette autre tâche qui doit être terminée avant que la tâche courante puisse être exécutée, une composante nulle indiquant que la tâche courante ne dépend pas de la tâche associée à la composante nulle.
Afin d'accélérer le procédé, on prévoit dans un système processeur un module de comparaison de deux données de Nm bits, comprenant une sortie de comparaison indicative d'une relation d'ordre entre les deux données, ladite sortie étant définie par une table comprenant des rangées associées aux valeurs possibles consécutives de la première donnée et des colonnes associées aux valeurs possibles consécutives de la deuxième donnée, où chaque rangée comprend un état 1 à l'intersection avec la colonne associée à la même valeur, suivi d'une série d'états 0. La série d'états 0 est suivie d'une série d'états 1 complétant la rangée de manière circulaire, le nombre d'états 0 étant le même pour chaque rangée et inférieur à la moitié de la valeur maximale des données.
Un comparateur de deux vecteurs selon une relation d'ordre partiel, où chaque vecteur comprend des composantes ayant un nombre de bits multiple de Nm, comprend une pluralité de modules de comparaison du type susmentionné, connectés dans une chaîne par des bornes de propagation de retenue ; une porte disposée entre les bornes de propagation de retenue de deux modules consécutifs, apte à interrompre la propagation de retenue entre lesdits modules consécutifs en réponse à un état actif d'un signal déterminant une frontière entre composantes ; et une porte disposée à la sortie de comparaison, apte à inhiber la prise en compte de l'état de cette sortie en réponse à un état inactif du signal de détermination de frontière.
Selon un mode de réalisation, chaque module comprend une sortie d'égalité indicative de l'égalité des données présentées au module, et le comparateur comprend de la logique prévue pour établir une indication active si et seulement si toutes les sorties de comparaison des modules sont actives et la sortie d'égalité d'au moins un module est inactive.
Description sommaire des figures D'autres avantages et caractéristiques ressortiront plus clairement de la description qui va suivre de modes particuliers de réalisation donnés à titre d'exemples non limitatifs et illustrés à l'aide des dessins annexés, dans lesquels : la figure 1 représente un exemple élémentaire de succession de tâches à exécuter dans un processus de type flot de données ; la figure 2 est un graphe révélant les dépendances entre différentes occurrences de chaque tâche de la figure 1 ; la figure 3 correspond au graphe de la figure 2, où chaque occurrence d'une tâche est numérotée par un vecteur de temps logique utilisé pour identifier les dépendances entre occurrences des tâches ; la figure 4 reprend le graphe de la figure 3 avec des durées d'exécution différentes pour certaines occurrences de tâches ; la figure 5 représente un exemple de succession de tâches dans un processus de type flot de données, avec deux tâches à exécution alternative ; la figure 6 est un graphe numéroté par des vecteurs de temps logique des occurrences des tâches de la figure 5 ; la figure 7 est un graphe représentant un exemple de trace d'exécution d'un traitement correspondant à la figure 5, numéroté par des vecteurs de temps logique et des valeurs de compteurs de dépendances ; la figure 8 représente un graphe d'un autre cas de trace d'exécution ; et - la figure 9 représente schématiquement un mode de réalisation de comparateur de vecteurs selon un ordre partiel.
Description d'un mode de réalisation préféré de l'invention
Afin de réaliser le suivi des conditions à satisfaire pour démarrer une occurrence d'une tâche dans un système multi-tâches, notamment des tâches d'un processus de type flot de données, on prévoit ici de maintenir pour chaque tâche un vecteur de temps logique représentatif des dépendances de la tâche.
Ci-après, on entend par « tâche » un ensemble générique de traitements. Par « exécution » de la tâche, ou une « occurrence » de la tâche, on entend l'exécution de la tâche sur un jeu spécifique de données (dans un traitement de type flot de données, on exécute des occurrences consécutives d'une même tâche sur des jeux de données consécutifs d'un flot entrant). Les vecteurs de temps logique sont associés à chaque tâche et reflètent les dépendances de l'occurrence courante de la tâche.
La notion de temps logique vectoriel est introduite dans les articles [M. Raynal et M. Singhal, "Logical time: capturing causality in distributed Systems", IEEE Computer 29(2), 1996] et [C. Fidge, "Logical time in distributed Computing Systems", IEEE Computer 24(8), 1991 ].
Les vecteurs de temps logique, associés à une relation d'ordre partiel, ont été utilisés pour dater des événements transmis d'un processus à un autre, afin que chaque processus qui reçoit des événements par des voies distinctes puisse les réordonner de manière causale. En d'autres termes, un vecteur de temps logique sert normalement à identifier et dater relativement un événement survenu dans le passé.
Comme on le comprendra ci-après, les vecteurs de temps logique sont utilisés, dans la présente demande, pour déterminer à partir de quel instant une tâche peut être exécutée. En d'autres termes, les vecteurs de temps logique servent à contraindre l'ordre d'exécution des tâches, c'est-à-dire à organiser des événements dans le futur.
Cette utilisation des vecteurs de temps logique sera décrite plus en détail ci- après à l'aide exemples de traitements de type flot de données.
La figure 1 symbolise un traitement élémentaire de type flot de données. Une tâche A fournit une donnée à une tâche B, qui la traite et fournit le résultat à une tâche C. Les tâches communiquent leurs données par l'intermédiaire de mémoires tampon (FIFO), dont la profondeur est de 3 dans cet exemple. Les conditions d'exécution de ces tâches sont les suivantes. La tâche A ne peut s'exécuter que si la première mémoire tampon n'est pas pleine. La tâche B ne peut s'exécuter que si la première mémoire tampon n'est pas vide et la deuxième mémoire tampon n'est pas pleine. La tâche C ne peut s'exécuter que si la deuxième mémoire tampon n'est pas vide. La figure 2 est un graphe représentant les dépendances entre les occurrences des tâches A , B et C. Les rangées correspondent respectivement aux tâches A, B et C. Les cercles consécutifs dans une rangée correspondent à des occurrences consécutives de la même tâche, numérotées dans les cercles. Les colonnes correspondent à des cycles d'exécution consécutifs, en supposant, pour simplifier, que chaque occurrence d'une tâche se termine en un cycle.
Des flèches relient des occurrences dépendantes. Chaque flèche signifie « doit avoir lieu avant ». En d'autres termes, dans le graphe tel que représenté, chaque flèche doit pointer vers la droite ; elle ne peut ni pointer vers la gauche, ni être verticale. Les flèches en trait plein correspondent à des dépendances imposées par l'ordre d'exécution des tâches. Les flèches en pointillés correspondent aux dépendances imposées par la profondeur (limitée) des mémoires tampon.
Comme la première occurrence de la tâche A doit être exécutée avant la première occurrence de la tâche B, et que celle-ci doit être exécutée avant la première occurrence de la tâche C, les occurrences sont décalées d'un cycle d'une rangée à la suivante. La figure 3 représente le graphe de la figure 2 où chaque occurrence d'une tâche est annotée par un vecteur de temps logique selon le procédé visé ici. Un vecteur de temps logique est associé à chaque tâche, et mis à jour à la fin de chaque occurrence de la tâche. Comme les mises à jour de ces vecteurs correspondent à des incrémentations, ces vecteurs peuvent aussi être dénommés « horloges logiques », notées H.
Pour simplifier la description, on se place dans le cas le plus simple à comprendre où chaque vecteur ou horloge H comprend une composante associée à chaque tâche exécutable sur un système multi-tâches. Il existe des techniques permettant, dans le cadre connu d'utilisation des vecteurs de temps logique, d'optimiser le nombre de composantes par rapport au nombre de tâches - ces techniques sont également applicables ici. Un exemple de telle technique est décrit dans l'article [P. A. S. Ward, « An offline algorithm for dimension-bound analysis », Proceeding of the 1999 IEEE International Conférence on Parallel Processing, pages 128-136]. Ainsi, à la figure 3, on a trois vecteurs H(A), H(B), et H(C) affectés respectivement aux tâches A, B et C, et chaque vecteur a trois composantes affectées respectivement aux tâches A, B et C.
Une composante h. associée à une tâche Ti d'un vecteur H(Tj) associé à une tâche Tj contient, par exemple, l'occurrence de la tâche Ti nécessaire à l'exécution de l'occurrence courante de la tâche Tj. Par extension, la composante hj associée à la tâche Tj contient l'occurrence de la tâche Tj en cours d'exécution. Une composante nulle indique que l'occurrence courante de la tâche associée au vecteur ne dépend pas de la tâche associée à la composante nulle.
Par exemple, comme on l'a identifié à la figure 3 pour un cycle d'exécution t7, la première composante du vecteur H(A), correspondant à la tâche A, contient 7, qui est l'occurrence courante de la tâche A. Cette occurrence de la tâche A nécessite que la première mémoire tampon (figure 1 ) dispose d'au moins un emplacement, c'est-à-dire que la 4e occurrence de la tâche B ait consommé une donnée dans cette mémoire tampon ; la composante (la 2e) associée à la tâche B dans le vecteur H(A) contient 4. La 4e occurrence de la tâche B nécessite que la deuxième mémoire tampon dispose d'au moins un emplacement, c'est-à-dire que la 1 e occurrence de la tâche C ait consommé une donnée dans cette mémoire tampon ; la composante (la 3e) associée à la tâche C dans le vecteur H(A) contient 1 .
On construit chaque vecteur à partir du graphe en suivant vers l'arrière les flèches de l'occurrence considérée vers l'occurrence la plus proche de chacune des autres tâches. Ainsi, le vecteur H(B) à l'instant t7 contient (6, 6, 3), et le vecteur H(C) contient (5, 5, 5). S'il n'existe pas de telle flèche à suivre en arrière, la composante est nulle, ce qui est le cas pour les premières occurrences des tâches A et B. La construction des vecteurs s'avère simple à réaliser à l'exécution d'une application mettant en œuvre les tâches. On s'aperçoit qu'il suffit, à partir d'une certaine occurrence (ici la sixième pour la tâche A, la troisième pour la tâche B, et la première pour la tâche C), d'incrémenter systématiquement chacune des composantes à chaque exécution de la tâche associée. Il suffit de définir à l'avance les conditions initiales et de mise à jour des vecteurs, ce qui peut être fait par le compilateur, en fonction du type de graphe décrivant les dépendances des tâches. Ces conditions s'expriment sous la forme « incrémenter la composante Xi du vecteur X à partir de la k-ième occurrence ». Les vecteurs sont stockés dans une mémoire partagée et mis à jour par un processus d'ordonnancement des tâches auprès duquel chaque tâche est « enregistrée » par l'application.
A titre d'exemple, les conditions initiales et de mise à jour du vecteur H(A) dans la figure 3 peuvent être définies de la manière suivante :
Figure imgf000010_0001
Afin d'exploiter les vecteurs de temps logique par la suite, on définit une relation d'ordre partiel sur l'ensemble de ces vecteurs. La relation d'ordre partiel entre deux vecteurs X(xo, X2, ... xn) et Y(yo, yi , ... yn) est définie telle que :
X < Y est vrai si et seulement si : quel que soit i compris entre 0 et n, on et il existe j compris entre 0 et n tel que xj < yj.
Figure imgf000010_0002
Cette relation d'ordre est dite « partielle » parce qu'elle n'ordonne pas tous les vecteurs entre eux. Dans certains cas, les vecteurs X et Y ne sont pas comparables, ce que l'on note par X || Y.
On considère maintenant une tâche Ta en attente d'exécution, et on souhaite savoir à un instant courant si cette tâche peut être exécutée. Pour cela, on compare le vecteur courant de la tâche Ta à chacun des vecteurs courants des autres tâches. La tâche Ta peut être exécutée seulement si, quelle que soit l'autre tâche T, on a :
H (Ta) < H(T) ou H (Ta) || H(T), condition que l'on pourra aussi noter
Figure imgf000010_0003
Si pour au moins une autre tâche T on a H(Ta) > H(T), toutes les conditions ne sont pas réunies pour exécuter la tâche Ta, donc la tâche Ta doit attendre.
Dans le graphe de la figure 3, qui correspond à un cas simpliste, on s'aperçoit que les vecteurs dans chaque colonne à partir de la troisième sont incomparables deux à deux. Cela signifie que chacune des tâches correspondantes peut être exécutée en parallèle.
Pour la première colonne, on a H(C) > H(B) > H(A), signifiant que seule la tâche A peut être exécutée. Pour la deuxième colonne, on a H(C) > H(B), H(B) || H (A) et H (A) || H(C), signifiant que les tâches A et B peuvent être exécutées en parallèle, mais que la tâche C doit attendre.
Dans un cas plus proche de la réalité, les tâches arrivent avec plus ou moins de retard et elles mettent plus ou moins longtemps à s'exécuter.
La figure 4 représente le graphe de la figure 3 modifié pour représenter un cas plus proche de la réalité. Les deux premières occurrences de la tâche B durent deux fois plus longtemps que les autres occurrences. Il en résulte que : la première occurrence de la tâche C démarre avec un cycle de retard, la deuxième occurrence de la tâche C démarre avec deux cycles de retard, et la cinquième occurrence de la tâche A démarre avec un cycle de retard.
Le vecteur de temps logique d'une tâche reste constant sur le nombre de cycles requis pour l'exécution de la tâche associée, ce que l'on voit pour les deux premières occurrences de la tâche B. Un vecteur est mis à jour au moment où la tâche se termine. Ainsi, comme on le voit pour les tâches A et B à la cinquième colonne, la nouvelle valeur du vecteur est en vigueur dès la fin de la tâche associée, et invariante pendant le temps d'attente d'une nouvelle occurrence de la tâche (ce qui est le cas aussi pendant le temps d'attente de l'exécution de la première occurrence des tâches B et C).
On comprendra mieux l'utilisation des vecteurs de temps logique à l'aide de ce graphe. A la troisième colonne, on a H(C) > H(B). Donc, contrairement au cas de la figure 3, la tâche C ne peut encore démarrer. La tâche C peut démarrer à la quatrième colonne, où les vecteurs deviennent incomparables deux à deux. A la cinquième colonne, on a H(A) > H(B) et H(C) > H(B). Ainsi, les tâches A et C doivent attendre, tandis que la tâche B s'exécute. Les tâches A et C pourront être exécutées à la sixième colonne, où les vecteurs deviennent incomparables deux à deux.
On s'aperçoit que le graphe peut ainsi se prolonger jusqu'à l'infini, et donc loger des occurrences de n'importe quelle durée avec n'importe quel retard. Cela garantit l'absence d'inter-blocages. Comme on l'a précédemment évoqué, les vecteurs de temps logique sont mis à jour par incrémentation systématique de leurs composantes. On ne peut pas envisager en pratique que les composantes tendent vers l'infini. On prévoit de préférence un mécanisme de repliement basé sur une relation d'ordre partiel adaptée sur un sous-ensemble des entiers naturels. Ainsi, les composantes des vecteurs sont définies modulo M, et la relation d'ordre partiel entre deux vecteurs X(xo, X2, . . . xn) et Y(yo, yi , ... yn) est définie telle que :
X < Y est vrai si et seulement si : quel que soit
Figure imgf000012_0002
la relation
Figure imgf000012_0001
étant vraie si et seulement si :
Figure imgf000012_0003
M et S sont des entiers tels que 2S < M, et M est supérieur à l'écart maximum entre composantes d'un vecteur. Dans le cas de la figure 3, l'écart maximum est de 6, pour le vecteur H(A) à partir de la septième occurrence. Cet écart maximum est déterminable à partir de l'instant où toutes les conditions initiales ont été prises en compte, c'est-à-dire à partir de l'instant où on commence à incrémenter toutes les composantes de tous les vecteurs.
Dans l'exemple de la figure 3, avec M = 8 et S = 3, les composantes des vecteurs sont repliées à parti de la valeur 7. Les deux derniers vecteurs du graphe pour la tâche A s'expriment ainsi par (0, 5, 2) et (1 , 6, 3), et le dernier vecteur du graphe pour la tâche B s'exprime par (0, 0, 5).
En considérant les huit valeurs possibles de chaque composante sur un cercle, la comparaison des composantes par la relation « inférieur à »
Figure imgf000012_0005
définie ci- dessus est telle qu'une valeur x est inférieure à chacune des 3 (S) valeurs suivantes, et supérieure à chacune des 4 (M - S -1 ) valeurs précédentes sur le cercle. On a par exemple :
Figure imgf000012_0004
Selon la méthodologie précédemment décrite, à chaque cycle d'exécution, on compare le vecteur de temps logique de chaque tâche à chacun des vecteurs des autres tâches, pour savoir si la tâche peut être exécutée. Cela représente des ressources de calcul significatives si le nombre de tâches est important : le nombre de comparaisons augmente de manière quadratique avec le nombre de tâches. En outre, même si le résultat des comparaisons indique qu'une tâche peut être exécutée, il se peut que la tâche ne puisse pas être exécutée immédiatement compte tenu des ressources de calcul disponibles (on dira que la tâche est exécutable). Il convient donc de gérer une liste de tâches exécutables.
Pour réduire les ressources de calcul, et faciliter la planification des tâches exécutables, on propose d'associer à chaque tâche un compteur de dépendances, noté K, dont le contenu est représentatif du nombre de conditions à satisfaire pour que la tâche soit exécutable. En pratique, le contenu du compteur est égal au nombre de conditions restant à satisfaire ; lorsque le contenu devient nul, la tâche devient exécutable.
Afin de mettre à jour les compteurs de dépendances, on procède de la manière suivante.
A l'initialisation du système, on effectue : H(T) := Ho(T) et K(T) := 0, où Ho(T) est un vecteur de départ pour la tâche T, par exemple (1 , 0, 0) pour la tâche A, (1 , 1 , 0) pour la tâche B, et (1 , 1 , 1 ) pour la tâche C, dans le cas de la figure 3.
Ensuite, le processus d'ordonnancement observe les contenus des compteurs de dépendances et lance l'exécution de chaque tâche dont le compteur est à zéro, ou bien planifie l'exécution de ces tâches si les ressources ne permettent pas de lancer leur exécution en parallèle.
A chaque fois qu'une tâche T se termine, les quatre étapes suivantes sont effectuées, et cela de manière atomique, c'est-à-dire avant de lancer l'exécution d'une nouvelle occurrence d'une tâche : 1. Pour chaque autre tâche Ta pour laquelle on a H(Ta) > H(T), on effectue K(Ta) := K(Ta) - 1 . En d'autres termes, la tâche T qui vient de se terminer remplit l'une des conditions pour que chacune des ces tâches Ta puisse s'exécuter.
2. On met à jour le vecteur H(T) pour la nouvelle occurrence de la tâche T.
Comme on l'a évoqué, cela peut être réalisé en incrémentant chaque composante du vecteur dès que le nombre d'occurrences atteint une valeur seuil définie pour la composante dans les conditions initiales.
3. Pour chaque autre tâche Ta pour laquelle on a H(T) > H(Ta), on effectue K(T) := K(T) + 1 . En d'autres termes, on identifie toutes les conditions requises pour l'exécution de la nouvelle occurrence de la tâche T, et on les comptabilise dans le compteur de dépendances de la tâche T.
4. Pour chaque autre tâche Ta pour laquelle on a H(Ta) > H(T), on effectue K(Ta) := K(Ta) + 1 . En d'autres termes, on identifie les nouvelles conditions créées par la nouvelle occurrence de la tâche T pour les autres tâches Ta, et on les comptabilise dans les compteurs de dépendances de ces autres tâches.
Les compteurs de dépendances peuvent être réalisés sous forme matérielle et surveillés en parallèle par un circuit de détection de contenu nul. On peut par ailleurs aussi stocker les vecteurs de temps logique dans des registres dédiés, reliés à des comparateurs sous forme matérielle, connectés pour incrémenter et décrémenter les compteurs selon les règles susmentionnées. (Bien entendu, on prévoit suffisamment de compteurs matériels et registres dédiés aux vecteurs pour satisfaire le nombre de tâches distinctes prévues dans les applications que l'on souhaite exécuter sur le système.) Dans ce cas, le logiciel système (le processus d'ordonnancement) se charge seulement de la mise à jour des vecteurs dans les registres dédiés, les comparaisons et mises à jour des compteurs étant réalisées par accélération matérielle.
Les compteurs de dépendances fournissent un indicateur d'imminence d'exécution, ils peuvent donc être utilisés, par exemple, pour piloter des opérations de préchargement des données. En outre, on s'aperçoit que le nombre de comparaisons croît de manière linéaire en fonction du nombre de tâches.
La figure 5 représente un exemple plus complexe de succession de tâches dans un processus de type flot de données, avec deux tâches à exécution alternative. La tâche B de la figure 1 comprend ici deux tâches, B et B', dont une seule est choisie pour exécution lorsque la tâche A se termine. Chaque donnée produite par une occurrence de la tâche A est aiguillée par un élément de sélection SEL vers l'une des tâches B et B'. La sélection est opérée par une donnée de commande CTL, également produite par la tâche A, et empilée dans une mémoire FIFO de même profondeur que les mémoires FIFO disposées entre les tâches A, B et C. Cette donnée de commande CTL est prise en compte en même temps par un élément de fusion MRG qui choisit la sortie de la tâche B ou B' active pour la transmettre à la tâche C. La figure 6 est un graphe de dépendances correspondant au cas de la figure 5, représenté dans l'hypothèse simplifiée où les occurrences des tâches ont la même durée et ne présentent pas de retard (comme le graphe de la figure 3). On a noté les valeurs des vecteurs de temps logique à l'intérieur des nœuds représentant les occurrences. Les vecteurs ont ici quatre composantes. En outre, on a utilisé la notation repliée des vecteurs, avec des composantes définies modulo 8.
Pour des raisons de clarté, on n'a pas représenté toutes les flèches de dépendances. On a seulement représenté les flèches provenant des première et quatrième occurrences de chaque tâche, sachant que les autres ne constituent qu'une copie d'une occurrence à la suivante. Les dépendances sont construites de la même manière que pour le graphe de la figure 3, en considérant qu'une flèche arrivant ou partant d'une occurrence de la tâche B à la figure 3 est ici dupliquée pour chacune des tâches B et B'. Par ailleurs, il convient de noter la présence d'une flèche partant de chaque occurrence de la tâche B vers l'occurrence suivante de la tâche B', et d'une flèche partant de chaque occurrence de la tâche B' vers l'occurrence suivante de la tâche B.
Une particularité du flot de la figure 5 est qu'on exécute une seule des deux tâches B et B' entre les tâches A et C. Pour tenir compte de cela dans la méthodologie décrite ci-dessus, on émet l'hypothèse que les deux tâches B et B' sont exécutées en même temps à chaque exécution d'une seule de ces deux tâches. En d'autres termes, à chaque exécution de la tâche B ou B', on met à jour les vecteurs des deux tâches, et, dans le cas où on utilise des compteurs de dépendances K, on met à jour de la même manière les compteurs des deux tâches. La figure 7 représente un exemple de trace d'exécution d'un traitement selon le graphe de la figure 6. Les nœuds en trait plein correspondent à des occurrences exécutées ou en cours d'exécution des tâches. Les nœuds en pointillés correspondent à des occurrences en attente d'exécution. Des flèches de dépendances n'apparaissent qu'à la fin de l'exécution d'une occurrence, c'est-à-dire au moment où on recalcule les vecteurs H et compteurs K. Chaque noeud contient les valeurs correspondantes du vecteur de temps logique et du compteur de dépendances K, dont les valeurs sont mises à jour selon les quatre étapes atomiques précédemment décrites. Pour les valeurs initiales des compteurs K des tâches A, B, B', et C, on suppose que chacune de ces tâches vient de se terminer et que son vecteur H a été mis à jour à sa valeur initiale. En appliquant la troisième étape de mise à jour des compteurs K à chacune des tâches, ceux-ci sont initialisés respectivement à 0, 1 , 1 , et 3. Au démarrage, on parvient à exécuter trois occurrences de la tâche A sur trois cycles consécutifs. La première de ces occurrences démarre la première occurrence de la tâche B qui met trois cycles à se terminer. On considère, du point de vue de son vecteur et de son compteur de dépendances, que la première occurrence de la tâche B' avance en même temps que la première occurrence de la tâche B.
La quatrième occurrence de la tâche A, la deuxième occurrence de la tâche B/B', en fait B', et la première occurrence de la tâche C peuvent démarrer au cinquième cycle. Considérant que les tâches B et B' se terminent en même temps au quatrième cycle, le compteur K de la tâche C au cinquième cycle se trouve décrémenté de 2, en appliquant deux fois la première étape de mise à jour des compteurs, une fois pour la tâche B, et une fois pour la tâche B'.
La quatrième occurrence de la tâche A dure 6 cycles, la deuxième occurrence de la tâche B' dure un cycle, et la première occurrence de la tâche C dure deux cycles. Au huitième cycle, pendant que la quatrième occurrence de la tâche A est encore en cours, on est parvenu à terminer la troisième occurrence de la tâche B/B' (en fait B) et lancer la deuxième occurrence de la tâche C. La quatrième occurrence de la tâche B/B' (en fait B') doit attendre le onzième cycle, quand la quatrième occurrence de la tâche A se sera terminée.
Dans les exemples d'exécution de tâches décrits jusqu'à maintenant, on n'a pas montré l'utilité de la quatrième étape de mise à jour des compteurs K. La figure 8 est une trace d'un exemple simple d'exécution de deux tâches A et B où cette quatrième étape s'avère utile. On utilise les mêmes conventions de représentation qu'à la figure 7. Chaque occurrence d'une tâche A produit trois données, dont chacune est consommée par une occurrence distincte de la tâche B. On suppose également que la mémoire FIFO entre les tâches A et B a une profondeur de trois données - il en résulte que chaque occurrence de la tâche A remplit la mémoire FIFO d'un coup. Ainsi, une deuxième occurrence de la tâche A ne peut démarrer qu'après la troisième occurrence de la tâche B, qui finit de libérer la mémoire FIFO.
On remarque ici que la deuxième composante du vecteur H(A) est incrémentée de 3 à chaque exécution d'une occurrence de la tâche A, étant donné que le démarrage d'une occurrence de la tâche A est subordonné à l'exécution de trois occurrences consécutives de la tâche B. On remarque aussi que la première composante du vecteur H(B) n'est incrémentée qu'après chaque troisième exécution d'une occurrence de la tâche B. Cela traduit que trois occurrences consécutives de la tâche B sont subordonnées à une même occurrence de la tâche A.
Si on applique les quatre étapes du procédé de mise à jour des compteurs de dépendances K dès la fin de la première occurrence de la tâche B, on a, avec T = B et Ta = A : 1 . H (A) = (2, 3) > H(B) = (1 , 1 ) => K(A) := K(A) - 1 = 0 ;
2. H(B) := (1 , 2) ;
3. On n'a pas H(B) > H (A). K(B) reste inchangé ;
4. H (A) = (2, 3) > H(B) = (1 , 2) => K(A) := K(A) + 1 = 1 . On rétablit la valeur initiale, correcte, de K(A), qui avait été transitoirement modifiée à l'étape 1 . Ces quatre étapes sont effectuées de manière atomique de manière que la valeur transitoire de K issue de l'étape 1 soit rétablie à sa valeur d'origine à l'étape 4 et n'affecte pas la liste des tâches prêtes.
A chacune des étapes 1 , 3 et 4 de mise à jour des compteurs K, on effectue N- 1 comparaisons de vecteurs de temps logique, où N est le nombre de tâches, et chaque comparaison consiste à comparer deux à deux au plus N composantes de vecteurs. Le nombre de comparaisons de composantes croît ainsi quadratiquement avec le nombre de tâches. Ces opérations peuvent être réalisées de manière logicielle par le processus d'ordonnancement, mais il serait souhaitable de prévoir une assistance matérielle permettant de libérer des ressources logicielles.
La comparaison étant une comparaison utilisant un ordre partiel, et les composantes étant de préférence bornées avec repliement, les comparateurs numériques classiques ne conviennent pas. La figure 9 représente les premiers éléments répétitifs d'un mode de réalisation de comparateur de vecteurs de temps logique HA et HB pouvant satisfaire ces besoins.
On suppose qu'un vecteur de temps logique est défini sur un nombre borné Nv de bits, par exemple 64, et que chaque composante de ce vecteur peut être définie sur un nombre programmable de bits, multiple d'un nombre minimal Nm, par exemple 4. Ce nombre Nm détermine le nombre maximal de composantes d'un vecteur. Ainsi, avec un vecteur de 64 bits et un nombre minimal de 4 bits, on peut définir au plus 16 composantes de 4 bits, et toute combinaison avec moins de composantes définies sur des multiples de 4 bits. Le comparateur de la figure 9 comprend une série de modules de comparaison 10 connectés à la chaîne. Chaque module 10 traite 4 bits de deux composantes à comparer de deux vecteurs HA et HB. Un module 10 peut être apparenté, du point de vue de ses bornes externes, à un comparateur basé sur un soustracteur effectuant la somme de son entrée A et du complément à 2 (~B + 1 ) de son entrée B. Ainsi, le module 10 comprend, outre une entrée pour chacune des données à comparer, une entrée de retenue Ci, une sortie de retenue Co, une sortie E indiquant si A = B, et une sortie GE indiquant si A□ B. On pourra dans un premier temps, pour simplifier la description, considérer que les modules 10 sont des comparateurs classiques. Comme on le verra ci-après, la table logique de ces modules sera adaptée pour réaliser la comparaison de valeurs repliées. Les modules 10 sont mis à la chaîne par leurs sorties de retenue et leurs entrées de retenue Co et Ci, de manière à construire un comparateur de deux données de 64 bits. Les frontières entre les composantes des vecteurs sont définies à l'aide de portes ET 12, une porte 12 étant disposée entre chaque sortie de retenue Co d'un module et l'entrée de retenue Ci du module suivant. L'entrée de retenue du premier module reçoit 0 (pas de retenue à prendre en compte).
Chaque porte 12 est commandée par un signal S respectif (S0, S1 , S2...) dont l'état actif (1 ) détermine une frontière entre composantes. L'état actif du signal S bloque la porte 12, d'où il résulte que la retenue du module 10 n'est pas transmise au module suivant, et que le module suivant ne propage pas la comparaison - ce module suivant effectue une comparaison indépendante.
Un signal S inactif (0) rend passante la porte 12 et provoque le chaînage de deux modules 10 en permettant la propagation de retenue. Ces deux modules sont ainsi associés à une même composante. Dans la représentation de la figure 1 , si les quatre signaux S sont inactifs, les quatre modules 10 sont associés à une composante unique de 16 bits. Si les signaux S1 et S3 sont actifs, les modules sont associés à deux composantes distinctes de 8 bits. Si tous les signaux S sont actifs, chaque module est associé à une composante distincte de 4 bits. Par ailleurs, chaque signal S est appliqué sur une entrée inverseuse d'une porte OU 14, recevant sur une deuxième entrée la sortie GE du module 10 correspondant. Lorsque le signal S est inactif, la porte 14 ne propage pas la sortie GE du module - il s'agit d'un résultat de comparaison intermédiaire dont il ne faut pas tenir compte. Seul un module dont le signal S est actif voit sa sortie GE propagée par la porte 14 correspondante - cette sortie consolide le résultat de la comparaison établie par le module courant et des modules chaînés qui le précèdent (modules dont le signal S est inactif). Les sorties des portes 14 arrivent sur une porte ET 16, dont la sortie est par conséquent active si les sorties GE de tous les modules 10 sont actives, c'est- à-dire si chaque composante du vecteur HA est supérieure ou égale à la composante correspondante du vecteur HB
Figure imgf000020_0002
. (Les sorties des portes 14 bloquées par un signal S à 0 sont en fait à 1 , de sorte qu'elles n'influent pas sur les sorties des autres portes 14.)
Les sorties E inversées des modules 10 arrivent sur une porte OU 18. Ainsi, la sortie de la porte 18 devient active si au moins une des sorties E est inactive, c'est-à-dire si on a une inégalité pour au moins une paire de composantes des vecteurs HA et H B
Figure imgf000020_0003
Les sorties des portes 16 et 18 arrivent sur une porte ET 20. Ainsi, cette porte 20 fournit un signal actif (HA>HB) si toutes les composantes du vecteur HA sont supérieures ou égales à leurs composantes respectives du vecteur HB (porte 16 active), et qu'au moins deux composantes respectives des vecteurs HA et HB sont inégales (donc l'une strictement supérieure à l'autre). On obtient bien une comparaison de vecteurs selon une relation d'ordre partiel.
Il reste à définir comment les modules 10 comparent des composantes repliées. Les sorties de chaque module 10, dans le cadre de l'exemple où le module traite des données A et B de 4 bits, peuvent être définies comme suit : · Co = 1 si A + ~B + Ci > 15 (24 - 1 ). Cela correspond à la définition classique du bit de retenue dans un additionneur utilisé pour réaliser une comparaison.
• E = 1 si A = B.
• est la relation d'ordre « supérieur ou égal»
Figure imgf000020_0001
conforme à la définition précédemment donnée pour travailler sur des valeurs repliées modulo M (M = 16 ici).
Le tableau ci-dessous fournit, dans le cadre d'un exemple de repliement, les valeurs de la sortie GE en fonction de toutes les valeurs possibles de A et de B, indiquées en décimal.
Figure imgf000021_0001
Dans un comparateur classique, les valeurs situées sous la diagonale descendante, y compris les valeurs sur la diagonale, seraient toutes à 1 , et les valeurs situées au dessus de la diagonale seraient toutes à 0. Dans le comparateur utilisé ici, comme cela est indiqué en gras, le coin inférieur gauche, délimité entre (A, B) = (8, 0) et (15, 7), ne contient que des 0, et le coin supérieur droit, délimité entre (A, B) = (0, 9) et (6, 15), ne contient que des 1 . Exprimé autrement, chaque rangée comprend huit zéros consécutifs, partant de la valeur à 1 de la diagonale, suivis de huit uns consécutifs, ces valeurs se succédant de manière circulaire.
Cet exemple correspond à S = 7 (8 - 1 ) dans la définition générale de la relation d'ordre partiel sur des valeurs repliées (où 2S < M). En diminuant la valeur de S, on diminue le nombre de zéros consécutifs dans les rangées, en complétant par des uns. Par exemple, en prenant S = 5, on aura 6 zéros consécutifs et 10 uns consécutifs dans chaque rangée.
Si n modules 10 sont chaînés pour correspondre à une composante de 4n bits, malgré que chaque module 10 travaille de manière indépendante sur 4 bits, et donc sur des valeurs bornées à 15, l'ensemble des modules chaînés, par transmission de retenues, travaille sur des valeurs de 4n bits, bornées à 24n - 1 .
Si le nombre de composantes des vecteurs est supérieur à la capacité du comparateur, il est néanmoins possible d'effectuer la comparaison en utilisant le comparateur en plusieurs cycles de la manière suivante, à l'aide de quelques éléments supplémentaires.
Lors d'un premier cycle, on compare un premier jeu de composantes. La sortie de la porte 20 est ignorée et les états des sorties des portes 16 et 18 sont stockés pour le cycle suivant, par exemple dans des bascules.
Au cycle suivant, on présente un nouveau jeu de composantes au comparateur. La porte OU 18 reçoit en entrée supplémentaire l'état
Figure imgf000022_0001
précédemment stocké pour sa sortie. Ainsi, si une inégalité a été détectée au cycle précédent, cette détection est imposée au cycle courant. Par ailleurs, une porte ET supplémentaire 22 est interposée entre les portes 16 et 20. La sortie de cette porte 22 n'est active que si la sortie de la porte 16 et l'état précédemment stocké de cette sortie sont tous deux actifs.
Figure imgf000022_0002
La sortie de la porte 20 sera prise en compte au bout d'un nombre suffisant de cycles pour traiter toutes les composantes à l'aide du comparateur.
Bien que dans la description qui précède on se réfère à un état 1 comme un état actif, et à un état 0 comme un état inactif, on comprendra que les natures de ces états peuvent être échangées en adaptant les circuits logiques les utilisant sans changer le résultat recherché.

Claims

Revendications
1. Procédé d'exécution de plusieurs tâches interdépendantes sur un système multi-tâches, caractérisé en ce qu'il comprend les étapes suivantes :
• associer à chaque tâche (T) un vecteur de temps logique (H) indicatif de l'occurrence courante de la tâche et des occurrences d'un ensemble d'autres tâches (Ta) dont l'occurrence courante dépend ;
• définir une relation d'ordre partiel sur l'ensemble des vecteurs de temps logique, de manière qu'un premier vecteur soit considéré supérieur à un deuxième vecteur si toutes les composantes du premier vecteur sont supérieures ou égales aux composantes respectives du deuxième vecteur, et au moins une des composantes du premier vecteur est strictement supérieure à la composante respective du deuxième vecteur ;
• comparer les vecteurs de temps logique selon la relation d'ordre partiel ;
• exécuter la tâche (T) si son vecteur de temps logique n'est supérieur à aucun autre vecteur de temps logique ; et
• mettre à jour le vecteur de temps logique de la tâche exécutée (T) pour une nouvelle occurrence de la tâche, en incrémentant au moins une des composantes du vecteur.
2. Procédé selon la revendication 1 , comprenant les étapes suivantes :
• associer à chaque tâche un compteur de dépendances (K) indicatif du nombre de conditions à satisfaire pour exécuter une occurrence de la tâche ;
• planifier l'exécution de la tâche lorsque son compteur de dépendances atteint zéro ;
• lorsque la tâche (T) est exécutée, décrémenter le compteur de dépendances de chaque autre tâche (Ta) ayant un vecteur de temps logique supérieur à celui de la tâche exécutée ;
• mettre à jour le vecteur de temps logique de la tâche exécutée (T) ; • incrémenter le compteur de dépendances de la tâche exécutée(T) pour chaque autre tâche (Ta) dont le vecteur de temps logique est inférieur à celui de la tâche exécutée ; et
• incrémenter le compteur de dépendances de chaque autre tâche (Ta) ayant un vecteur de temps logique supérieur à celui de la tâche exécutée (T).
Procédé selon la revendication 1 , dans lequel le vecteur de temps logique (H) d'une tâche courante comprend une composante associée à chaque tâche possible,
• la composante associée à la tâche courante contenant le numéro d'occurrence de la tâche courante ;
• une composante associée à une autre tâche identifiant l'occurrence de cette autre tâche qui doit être terminée avant que la tâche courante puisse être exécutée ; et
• une composante nulle indiquant que la tâche courante ne dépend pas de la tâche associée à la composante nulle.
Procédé selon la revendication 3, comprenant les étapes suivantes pour mettre à jour le vecteur d'une tâche terminée :
• incrémenter la composante associée à la tâche terminée ; et
• incrémenter chaque autre composante si la composante associée à la tâche terminée a atteint une valeur seuil.
Procédé selon la revendication 1 , dans lequel :
• les vecteurs ont des composantes définies modulo M ;
• la relation d'ordre partiel entre deux vecteurs X(xo, X2, . . . xn) et Y(yo, yi , . .. yn) est définie telle que :
X < Y est vrai si et seulement si : quel que soit i compris entre
Figure imgf000024_0002
compris entre 0 et n tel que
Figure imgf000024_0001
la relation étant vraie si et seulement si :
Figure imgf000025_0001
Figure imgf000025_0002
S étant un entier tel que 2S < M.
Procédé selon la revendication 1 , dans lequel l'ensemble des tâches comprend deux tâches alternatives dont l'une ou l'autre est sélectionnable pour exécution en fonction du résultat produit par une tâche prédécesseur, l'étape de mise à jour du vecteur de la tâche alternative terminée comprenant la mise à jour du vecteur de l'autre tâche alternative.
PCT/FR2011/052175 2010-10-07 2011-09-21 Systeme d'ordonnancement de l'exécution de taches cadence par un temps logique vectoriel WO2012045941A1 (fr)

Priority Applications (3)

Application Number Priority Date Filing Date Title
EP11771244.8A EP2625609A1 (fr) 2010-10-07 2011-09-21 Systeme d'ordonnancement de l'exécution de taches cadence par un temps logique vectoriel
JP2013532242A JP2013539143A (ja) 2010-10-07 2011-09-21 論理時刻ベクトルに基づくタスクの実行をスケジュールするためのシステム
US13/824,429 US20130247058A1 (en) 2010-10-07 2011-09-21 System for scheduling the execution of tasks based on logical time vectors

Applications Claiming Priority (2)

Application Number Priority Date Filing Date Title
FR1003963A FR2965948A1 (fr) 2010-10-07 2010-10-07 Systeme d'ordonnancement de l'execution de taches cadence par un temps logique vectoriel
FR1003963 2010-10-07

Publications (1)

Publication Number Publication Date
WO2012045941A1 true WO2012045941A1 (fr) 2012-04-12

Family

ID=44318210

Family Applications (1)

Application Number Title Priority Date Filing Date
PCT/FR2011/052175 WO2012045941A1 (fr) 2010-10-07 2011-09-21 Systeme d'ordonnancement de l'exécution de taches cadence par un temps logique vectoriel

Country Status (5)

Country Link
US (1) US20130247058A1 (fr)
EP (1) EP2625609A1 (fr)
JP (1) JP2013539143A (fr)
FR (1) FR2965948A1 (fr)
WO (1) WO2012045941A1 (fr)

Cited By (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN104050215A (zh) * 2013-03-14 2014-09-17 三星电子株式会社 清除和重建相关性的系统和方法

Families Citing this family (5)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
FR2965946B1 (fr) * 2010-10-07 2012-12-14 Commissariat Energie Atomique Systeme d'ordonnancement de l'execution de taches cadence par un temps logique vectoriel
CN104536811B (zh) * 2014-12-26 2018-10-16 广州华多网络科技有限公司 基于hive任务的任务调度方法及装置
US9552229B2 (en) * 2015-05-14 2017-01-24 Atlassian Pty Ltd Systems and methods for task scheduling
US10541939B2 (en) * 2017-08-15 2020-01-21 Google Llc Systems and methods for provision of a guaranteed batch
US20190370076A1 (en) * 2019-08-15 2019-12-05 Intel Corporation Methods and apparatus to enable dynamic processing of a predefined workload

Citations (3)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US6016540A (en) * 1997-01-08 2000-01-18 Intel Corporation Method and apparatus for scheduling instructions in waves
US20020138714A1 (en) * 2001-03-22 2002-09-26 Sun Microsystems, Inc. Scoreboard for scheduling of instructions in a microprocessor that provides out of order execution
US20080005357A1 (en) 2006-06-30 2008-01-03 Microsoft Corporation Synchronizing dataflow computations, particularly in multi-processor setting

Family Cites Families (6)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
JPH05233597A (ja) * 1992-02-21 1993-09-10 Fujitsu Ltd スケジューリング問題における制約充足方法
US6574665B1 (en) * 1999-02-26 2003-06-03 Lucent Technologies Inc. Hierarchical vector clock
US7266571B2 (en) * 2004-07-27 2007-09-04 International Business Machines Corporation Method and system for scheduling a partial ordered transactions for event correlation
JP4749431B2 (ja) * 2005-03-04 2011-08-17 ヒューレット−パッカード デベロップメント カンパニー エル．ピー． パイプラインスループットを促進するための方法及び装置
US20070083411A1 (en) * 2005-03-25 2007-04-12 Yosef Alberton Schedule coordinates method for project scheduling
US7676483B2 (en) * 2005-09-26 2010-03-09 Sap Ag Executable task modeling systems and methods

Patent Citations (3)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US6016540A (en) * 1997-01-08 2000-01-18 Intel Corporation Method and apparatus for scheduling instructions in waves
US20020138714A1 (en) * 2001-03-22 2002-09-26 Sun Microsystems, Inc. Scoreboard for scheduling of instructions in a microprocessor that provides out of order execution
US20080005357A1 (en) 2006-06-30 2008-01-03 Microsoft Corporation Synchronizing dataflow computations, particularly in multi-processor setting

Non-Patent Citations (5)

* Cited by examiner, † Cited by third party
Title
C. FIDGE: "Logical time in distributed computing systems", IEEE COMPUTER, vol. 24, no. 8, 1991, XP000258964, DOI: doi:10.1109/2.84874
M. RAYNAL, M. SINGHAL: "Logical time: capturing causality in distributed systems", IEEE COMPUTER, vol. 29, no. 2, 1996
P. A. S. WARD: "An offline algorithm for dimension-bound analysis", PROCEEDING OF THE 1999 IEEE INTERNATIONAL CONFERENCE ON PARALLEL PROCESSING, pages 128 - 136
RAYNAL M ET AL: "CAPTURING CAUSALITY IN DISTRIBUTED SYSTEMS", COMPUTER, IEEE SERVICE CENTER, LOS ALAMITOS, CA, US, vol. 29, no. 2, 1 February 1996 (1996-02-01), pages 49 - 56, XP000556013, ISSN: 0018-9162, DOI: DOI:10.1109/2.485846 *
SEN A ET AL: "Predictive runtime verification of multi-processor SoCs in SystemC", DESIGN AUTOMATION CONFERENCE, 2008. DAC 2008. 45TH ACM/IEEE, IEEE, PISCATAWAY, NJ, USA, 8 June 2008 (2008-06-08), pages 948 - 953, XP031281037, ISBN: 978-1-60558-115-6 *

Cited By (5)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN104050215A (zh) * 2013-03-14 2014-09-17 三星电子株式会社 清除和重建相关性的系统和方法
KR20140113304A (ko) * 2013-03-14 2014-09-24 삼성전자주식회사 디펜던시들을 정리하고 리빌딩하는 시스템 및 방법
CN104050215B (zh) * 2013-03-14 2019-04-09 三星电子株式会社 清除和重建相关性的系统和方法
KR102010312B1 (ko) 2013-03-14 2019-08-13 삼성전자주식회사 디펜던시들을 정리하고 리빌딩하는 시스템 및 방법
US10552157B2 (en) 2013-03-14 2020-02-04 Samsung Electronics Co., Ltd. System and method to clear and rebuild dependencies

Also Published As

Publication number Publication date
FR2965948A1 (fr) 2012-04-13
US20130247058A1 (en) 2013-09-19
JP2013539143A (ja) 2013-10-17
EP2625609A1 (fr) 2013-08-14

Similar Documents

Publication Publication Date Title
WO2012045941A1 (fr) Systeme d&#39;ordonnancement de l&#39;exécution de taches cadence par un temps logique vectoriel
US10810343B2 (en) Mapping software constructs to synchronous digital circuits that do not deadlock
EP3912025B1 (fr) Langage et compilateur pour la génération d&#39;un circuit numerique synchrone qui maintient l&#39;ordre d&#39;exécution des fils
EP2870535B1 (fr) Procede d&#39;execution, au sein d&#39;un systeme embarque multitaches, d&#39;une application cadencee par plusieurs domaines de temps differents incluant une gestion d&#39;interruptions
EP1830264A1 (fr) Procédé et dispositif de sauvegarde et de restauration d&#39;une manière interruptible d&#39;un ensemble de registres d&#39;un microprocesseur
FR3053485A1 (fr) Procede et circuit de controle dynamique de consommation d&#39;energie
CA2348069A1 (fr) Systeme et methode de gestion d&#39;une architecture multi-ressources
FR3101980A1 (fr) Processeur
EP1869545B1 (fr) Dispositif implementant la multiplication modulaire de montgomery
EP2625597A1 (fr) Système d&#39;ordonnancement de l&#39;exécution de taches cadence par un temps logique vectoriel
EP0670069B1 (fr) Procede de demonstration automatique
KR20190038989A (ko) 나누기와 곱하기-빼기 연산들을 병합하기 위한 시스템 및 방법
FR2895602A1 (fr) Dispositif et procede d&#39;encodage de type cabac
FR2957434A1 (fr) Dispositif de test d&#39;une architecture de calcul multitaches et procede de test correspondant
EP3215933B1 (fr) Procede et dispositif d&#39;architecture configurable a gros grains pour executer en integralite un code applicatif
CA2778576C (fr) Procede et dispositif de traitement de taches optimise pour un fws
EP2784680B1 (fr) Procédé d&#39;exécution d&#39;un logiciel sécuritaire et d&#39;un logiciel non sécuritaire entrelacés
EP3234773B1 (fr) Procede d&#39;ordonnancement d&#39;un traitement audio d&#39;un vehicule automobile et systeme d&#39;exploitation associe
FR3014221A1 (fr) Procede de generation d&#39;un code logiciel pour la parallelisation d&#39;une fonction associative, programme d&#39;ordinateur et dispositif associes
WO2024058912A1 (fr) Arrêt de microservices tout en conservant une grande disponibilité
WO2023118261A1 (fr) Procédé de détermination d&#39;une grandeur physique et système de détermination associé
FR2929726A1 (fr) Procede d&#39;addition a operandes multiples, additionneur et produit programme d&#39;ordinateur correspondants.
FR2752964A1 (fr) Systeme et procede de traitement d&#39;image simple dans lesquels un temps systeme non souhaite est impossible
FR2978263A1 (fr) Procede de synthese de haut niveau d&#39;une application
FR2937762A1 (fr) Procede pour la conception d&#39;accelerateurs

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: 11771244

Country of ref document: EP

Kind code of ref document: A1

REEP Request for entry into the european phase

Ref document number: 2011771244

Country of ref document: EP

WWE Wipo information: entry into national phase

Ref document number: 2011771244

Country of ref document: EP

ENP Entry into the national phase

Ref document number: 2013532242

Country of ref document: JP

Kind code of ref document: A

NENP Non-entry into the national phase

Ref country code: DE

WWE Wipo information: entry into national phase

Ref document number: 13824429

Country of ref document: US