WO2021156308A2 - Procede de gestion de donnees echantillonnees partagees entre plusieurs unites de traitement - Google Patents

Procede de gestion de donnees echantillonnees partagees entre plusieurs unites de traitement Download PDF

Info

Publication number
WO2021156308A2
WO2021156308A2 PCT/EP2021/052546 EP2021052546W WO2021156308A2 WO 2021156308 A2 WO2021156308 A2 WO 2021156308A2 EP 2021052546 W EP2021052546 W EP 2021052546W WO 2021156308 A2 WO2021156308 A2 WO 2021156308A2
Authority
WO
WIPO (PCT)
Prior art keywords
semaphore
command
data
buffer
buffers
Prior art date
Application number
PCT/EP2021/052546
Other languages
English (en)
Inventor
Franck DELPECH
Nicolas Romea
Original Assignee
Vitesco Technologies GmbH
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 Vitesco Technologies GmbH filed Critical Vitesco Technologies GmbH
Publication of WO2021156308A2 publication Critical patent/WO2021156308A2/fr

Links

Classifications

    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F15/00—Digital computers in general; Data processing equipment in general
    • G06F15/16—Combinations of two or more digital computers each having at least an arithmetic unit, a program unit and a register, e.g. for a simultaneous processing of several programs
    • G06F15/163—Interprocessor communication
    • G06F15/173—Interprocessor communication using an interconnection network, e.g. matrix, shuffle, pyramid, star, snowflake
    • G06F15/17306—Intercommunication techniques
    • G06F15/17325—Synchronisation; Hardware support therefor
    • G—PHYSICS
    • G05—CONTROLLING; REGULATING
    • G05B—CONTROL OR REGULATING SYSTEMS IN GENERAL; FUNCTIONAL ELEMENTS OF SUCH SYSTEMS; MONITORING OR TESTING ARRANGEMENTS FOR SUCH SYSTEMS OR ELEMENTS
    • G05B2219/00—Program-control systems
    • G05B2219/30—Nc systems
    • G05B2219/34—Director, elements to supervisory
    • G05B2219/34333—Multi threading

Definitions

  • the invention relates to the field of computers comprising several processing units, such as a multi-core processor.
  • a computer executes software, implementing the application functions, broken down into cyclic (fixed period) or acyclic (aperiodic) recurring software tasks, such as a recurrence determined by an event linked to the rotation of the engine. Each of these tasks can be performed on one of the cores.
  • the processed information is stored as data and some must be exchanged between tasks. This data is typically stored in a global swap memory. Since the tasks are recurring, the data is recurrently read and written, by tasks that can run in parallel and with different recurrences or of a different type.
  • a task can be preempted by at least one priority interrupt. This prohibits any determinism or at least makes any reliable prediction of the load on the cores difficult.
  • a filling command named FILL (here FILL1), copies (upward arrow), typically from the global exchange memory MG, the data useful for a task T1 in a work buffer B1 dedicated to task T 1, before task T1 carries out its processing.
  • the task T1 reads r1, r2 the data which it needs from the buffer B1, carries out its processing by working on this data, possibly modifies them and writes the results w1, w2 in the buffer B1.
  • the data contained in the buffer B1 are restored by copying (downward arrow) the buffer B1 into the global exchange memory MG, by an emptying command, named FLUSH (here FLUSH1).
  • FILL and FLUSH commands can be centralized and automated, by the operating system. They advantageously concentrate all the management of concurrent access to data.
  • a semaphore SEM1 is a mechanism, managing a single token, allowing read or write access to a data or set of data to the entity that holds said token.
  • a task T1, T2 or command FILL, FLUSH wishing to access a datum must first take P (SEM1) the semaphore SEM1 corresponding to the datum. When it has taken the semaphore SEM1, the task T1, T2 can perform the access. Then the task T1, T2 returns or releases L (SEM1) the semaphore SEM1 which can then be used by another task.
  • a semaphore SEM1 in that it includes only a single token and is only available to a single requestor, can only be taken by one task or command at a time, which guarantees only one access to a given moment.
  • a task T 1, T2 or command FILL, FLUSH which wishes to take a semaphore SEM1, performs one or more attempts SEM17, and as long as it is already taken, is refused. Also she must wait for DT that he frees himself before being able to take him in turn, and to be able to carry out an access.
  • a semaphore SEM1 protects at least one piece of data, but most often several pieces of data grouped together in a set of data, said set being protected by a semaphore SEM1.
  • a FILL, FLUSH command generally requires taking several semaphores concerned, so as to be able to access all the data useful for the task T1, T2, in that said data can belong to different sets.
  • the semaphores corresponding to the data necessary for a task T1, T2 are taken in sequence, one after the other, the task T1, T2 or command FILL, FLUSH remaining pending DT when a semaphore SEM1 does not is not available, until released.
  • the time taken for an SEM1 semaphore to be taken up and occupied by a command is generally short, since it is limited to the time required to copy the data. But it can happen, as illustrated in Figure 2, that during a semaphore SEM1, the command FILL or FLUSH, is interrupted and possibly repeatedly. Since the interrupts 11, I2, I3, I4 have priority, this can drastically prolong the occupation time of the semaphore SEM1. This delays the task T1 during the execution of a protection command FILL, FLUSH, but can still cause a delay DT on another task T2, including a task T2 independent of the first task T 1, but requiring the same. semaphore SEM1.
  • the subject of the invention is a method for managing data shared between several processing units, the data being part between at least one set, each set comprising at least one data item, each set being previously copied into a buffer by means of 'a fill command, each copied set then being used by a processing and each copied set and possibly modified by the processing, being restored, at the end of the processing, by means of an emptying command, where a filling command and / or an emptying command use a semaphore univocally associated with each set / buffer, to guarantee a single access, at a given instant, at a datum of said set, where for a fill command or for a dump command, all the updates of the various buffers concerned are executed in parallel, iteratively until all the updates are carried out.
  • the method comprises an achievement indicator for each of the N buffers associated with a filling command or with an emptying command and a realization counter, where the method comprises the following steps: initialization of the realization indicators to FALSE, initialization of the counter at ZERO, initialization at ZERO of the index i, varying from 0 to N-1, iteration, until the counter is equal to N, by varying the index i, of the following steps: if the indicator of current realization is FALSE, and if the corresponding semaphore is available, seizure of the semaphore, update of the corresponding buffer, release of the semaphore, setting to TRUE of the current realization indicator, and incrementation of the counter,
  • the method further comprises a step of updating buffers not protected by a semaphore, carried out after the update of the buffers protected by a semaphore,
  • the number of data is of the order of a thousand and the number of semaphores is approximately equal to 12.
  • the invention relates to an application of said method to an internal combustion engine control command executed on a multi-core processor.
  • FIG. 2 already described, illustrates the problem of delay of a task in the event of preemption by interruptions
  • FIG. 4 shows a block diagram of the process according to the invention.
  • the invention relates to a method for managing sampled data shared between several processing units C1, C2.
  • the data are gone, they form a partition, between one and advantageously several sets.
  • a set is a set of data allowing a common processing, in particular in terms of protection: filling, emptying and semaphore in common.
  • Each game includes at least one item of data.
  • a data set, necessary for said task T1, T2 is copied into a buffer B1 from the global memory MG. This is achieved by a filling command FILL1, typically executed by the task T1, T2 which requires said data.
  • a copied set can then be used by a process or task T1 which works and possibly modifies the data thus protected in said buffer B1.
  • the data from the buffer B1 are restored by means of a FLUSH1 flush command which copies the data from the buffer B1 into the global memory MG.
  • the various filling commands FILL1 and the various emptying commands FLUSH1 use at least one semaphore SEM1, one semaphore SEM1 being univocally associated with each set / buffer B1. This makes it possible to guarantee a single access, at a given moment, to any data of any game.
  • a filling command FILL, FILL1 or a FLUSH flush command FLUSH1 executes all the updates of the various buffers B1 in parallel.
  • a filling or emptying command when it encounters an unavailable semaphore SEM1, does not wait and attempts to find another available or free semaphore, and updates the corresponding buffer when another semaphore is found available. This is iterated, going over all the semaphores not yet found free, until all the updates have been made.
  • Fi is a Boolean indicator associated with each buffer / semaphore. It is FALSE or equal to 0 initially and as long as the associated semaphore has not been found free or what is equivalent until the buffer has not been updated. It becomes TRUE or equal to 1 when the semaphore has been found free and the buffer has been updated.
  • the CTR counter counts the number of semaphores found free or what is equivalent to the number of buffers updated.
  • the method comprises the following steps, more particularly illustrated in FIG. 4.
  • An initialization step is carried out beforehand. It comprises: initialization of all the completion indicators Fi to FALSE or 0, initialization of the counter CTR to ZERO or 0, and initialization to ZERO or 0 of an index i, varying from 0 to N-1. Then an iteration is carried out until the counter CTR is equal to N, by varying the index i, of the following steps.
  • the current realization indicator Fi is FALSE, and if the corresponding semaphore SEMi is available, seizure of the semaphore SEMi, update of the corresponding buffer Bi, release of the semaphore SEMi, setting to TRUE of the corresponding realization indicator Fi to the current value of the index i, and incrementation of the counter CTR. Otherwise, if the current completion indicator Fi is TRUE, indicating a corresponding buffer already updated, or if the current SEMi semaphore is unavailable, because it is taken by another process, nothing is done, the end loop is reached and the iteration resumes, for the next index i. Note that the index i is incremented modulo N and that it it may be necessary to perform a large number, clearly greater than N, of iterations.
  • Data is not necessarily protected by semaphore, for example when it is only used by a single task or when it is atomic data.
  • atomic data data encoded over a length that can be read by the processor at a stroke, such as for example a byte for an 8-bit processor.
  • buffer protection even these data not protected by semaphore are advantageously subject to buffer protection.
  • the update of these buffers in read, FILL, or in FLUSH writing is advantageously carried out at the end of the update of the buffers protected by semaphore, as illustrated in FIG. 4, or after all the iterations.
  • the updating of buffers not protected by a semaphore can be carried out during the iteration. So once the N semaphores have been tested, with or without success, it may be interesting to insert all or part of the update of buffers not protected by a semaphore, before looping back to a new test of the semaphores, mainly when said test is negative, all remaining semaphores being unavailable. Also according to this characteristic, all or part of the updating of buffers not protected by a semaphore is advantageously carried out when the index i is equal to a given value modulo N. This value can, for example, be the value ZERO or 0, encountered after a full scan of all buffers / semaphores.
  • the number of semaphores is a delicate parameter to determine.
  • One semaphore per data item leads to too many semaphores and prohibitive processing times. On the contrary, too few semaphores lead to an increase in DT wait times.
  • the data are therefore advantageously grouped into sets, each set being associated with a semaphore SEM1.
  • the number of sets parameter and therefore the number of semaphores parameter can be configured.
  • a number of semaphores substantially equal to 12 appears to be a good measure.
  • the method according to the invention is advantageously applied to an internal combustion engine control command executed on a multi-core processor, each core constituting a processing unit C1, C2.
  • SEM1 SEMi: semaphore
  • N number of buffers, semaphores,

Landscapes

  • Engineering & Computer Science (AREA)
  • Physics & Mathematics (AREA)
  • Computer Hardware Design (AREA)
  • Theoretical Computer Science (AREA)
  • Mathematical Physics (AREA)
  • Software Systems (AREA)
  • General Engineering & Computer Science (AREA)
  • General Physics & Mathematics (AREA)
  • Multi Processors (AREA)
  • Debugging And Monitoring (AREA)

Abstract

Procédé de gestion de données partagées entre plusieurs unités de traitement (C1, C2), les données étant parties entre au moins un jeu, chaque jeu comprenant au moins une donnée, chaque jeu étant au préalable copié dans un buffer (B1) au moyen d'une commande de remplissage (FILL1), chaque jeu copié étant ensuite utilisé par un traitement (T1) et chaque jeu copié et éventuellement modifié par le traitement, étant restitué, à l'issue du traitement, au moyen d'une commande de vidage (FLUSH1), où une commande de remplissage (FILL1) et/ou une commande de vidage (FLUSH1) utilisent un sémaphore (SEM1) univoquement associé à chaque jeu / buffer (B1), pour garantir un unique accès, à un instant donné, à une donnée dudit jeu, où pour une commande de remplissage (FILL1) ou pour une commande de vidage (FLUSH1), toutes les mises à jour des différents buffers (B1) concernés sont exécutées en parallèle, itérativement jusqu'à ce que toutes les mises à jour soient réalisées.

Description

Description
Titre de l'invention : [Procédé de gestion de données échantillonnées partagées entre plusieurs unités de traitemenlj
[Domaine technique
L’invention concerne le domaine des calculateurs comprenant plusieurs unités de traitement, tel un processeur multi-cœur. Un tel calculateur exécute un logiciel, implémentant les fonctions applicatives, découpé en tâches logicielles récurrentes cycliques (à période fixe) ou acycliques (apériodiques, tel une récurrence déterminée par un évènement lié à la rotation du moteur). Chacune de ces tâches peut être exécutée sur l’un des cœurs. Les informations traitées sont stockées sous forme de données et certaines doivent être échangées entre les tâches. Ces données sont typiquement stockées dans une mémoire d’échange globale. Les tâches étant récurrentes, les données sont, de manière récurrente, lues et écrites, par des tâches pouvant s’exécuter en parallèle et selon des récurrences différentes ou de type différent. De plus une tâche peut être préemptée par au moins une interruption prioritaire. Ceci interdit tout déterminisme ou du moins rends difficile toute prévision fiable de la charge des cœurs.
Technique antérieure
Des accès simultanés ou concurrents à une même donnée sont préjudiciables en ce qu’ils peuvent conduire à des situations d’inconsistance des données. Des problèmes de stabilité et/ou de cohérence peuvent survenir si une donnée est écrite par une tâche alors qu’elle est en train d’être lue par une autre tâche.
Il est connu, pour éviter ces situations d’inconsistance, de protéger les données utilisées par une tâche, au moyen d’une copie dans un buffer, pendant au moins le temps du traitement par la tâche.
Aussi, tel qu’illustré à la figure 3, une commande de remplissage, nommée FILL (ici FILL1), recopie (flèche vers le haut), typiquement depuis la mémoire d’échange globale MG, les données utiles à une tâche T1 dans un buffer B1 de travail dédié à la tâche T 1 , avant que la tâche T1 ne réalise son traitement. La tâche T1 lit r1 , r2 les données dont elle a besoin depuis le buffer B1 , réalise son traitement en travaillant sur ces données, éventuellement les modifie et écrit les résultats w1 , w2 dans le buffer B1. A l’issue du traitement, les données contenues dans le buffer B1 sont restituées en recopiant (flèche vers le bas) le buffer B1 dans la mémoire d’échange globale MG, par une commande de vidage, nommée FLUSH (ici FLUSH1).
Ainsi durant tout le traitement par une tâche T1 , elle dispose de ses données cohérentes en ce qu’elles sont protégées dans un espace mémoire propre, constitué par le buffer B1.
Les commandes FILL et FLUSH peuvent être centralisées et automatisées, par le système d’exploitation. Elles concentrent avantageusement toute la gestion des accès concurrents aux données.
Afin de gérer les accès concurrents, il convient, pendant qu’une commande FLUSH recopie un buffer B1 en mémoire globale MG (écriture, vidage), d’empêcher toute commande FILL de recopier des données depuis la mémoire globale MG vers le buffer B1 (lecture, remplissage) et réciproquement empêcher toute écriture pendant une lecture. Aussi il est connu d’utiliser au moins un sémaphore pour protéger les données.
Tel qu’illustré à la figure 1 , montrant deux tâches T1 , T2 s’exécutant respectivement sur deux coeurs C1 , C2, un sémaphore SEM1 est un mécanisme, gérant un jeton unique, autorisant un accès en lecture ou en écriture à une donnée ou ensemble de données à l’entité qui détient ledit jeton. Une tâche T1, T2 ou commande FILL, FLUSH désirant accéder à une donnée doit préalablement prendre P(SEM1) le sémaphore SEM1 correspondant à la donnée. Lorsqu’elle a pris le sémaphore SEM1 , la tâche T1 , T2 peut réaliser l’accès. Ensuite la tâche T1 , T2 rend ou libère L(SEM1) le sémaphore SEM1 qui peut alors être utilisé par une autre tâche. Un sémaphore SEM1, en ce qu’il ne comprend qu’un unique jeton et n’est disponible que pour un seul demandeur, ne peut être pris que par une seule tâche ou commande, à la fois, ce qui garantit un seul accès à un instant donné. Une tâche T 1 , T2 ou commande FILL, FLUSH qui souhaite prendre un sémaphore SEM1, effectue une ou plusieurs tentatives SEM17, et tant qu’il est déjà pris, se le voit refuser. Aussi elle doit attendre DT qu’il se libère avant de pouvoir le prendre à son tour, et pouvoir réaliser un accès. Un sémaphore SEM1 protège au moins une donnée, mais le plus souvent plusieurs données regroupées dans un jeu de données, ledit jeu étant protégé par un sémaphore SEM1. Aussi une commande FILL, FLUSH nécessite généralement une prise de plusieurs sémaphores concernés, de manière à pouvoir accéder à toutes les données utiles à la tâche T1, T2, en ce que lesdites données peuvent appartenir à des jeux différents.
Classiquement la prise des sémaphores correspondant aux données nécessaires à une tâche T1 , T2 s’effectue en séquence, l’une après l’autre, la tâche T1 , T2 ou commande FILL, FLUSH restant en attente DT lorsqu’un sémaphore SEM1 n’est pas disponible, jusqu’à sa libération.
La durée de prise et d’occupation d’un sémaphore SEM1 par une commande est généralement courte, puisque limitée au temps nécessaire à la recopie des données. Mais il peut arriver, tel qu’illustré à la figure 2, que durant une prise de sémaphore SEM1, la commande FILL ou FLUSH, soit interrompue et ce éventuellement de manière répétée. Les interruptions 11, I2, I3, I4 étant prioritaires, ceci peut drastiquement prolonger la durée d’occupation du sémaphore SEM1. Ceci retarde la tâche T1 en cours d’exécution d’une commande de protection FILL, FLUSH, mais peut encore ocasionner un retard DT sur une autre tâche T2, y compris une tâche T2 indépendante de la première tâche T 1 , mais nécessitant ce même sémaphore SEM1.
Résumé de l'invention
Afin d’éviter de bloquer une tâche alors que celle-ci attend un sémaphore indisponible, le traitement des différents sémaphores est réalisé en parallèle. Ainsi si un sémaphore est indisponible, plutôt que d’attendre qu’il se libère, une commande de protection selon l’invention est autorisée à tester la disponibilité d’un autre sémaphore correspondant à une de ses données.
Aussi l’invention a pour objet un procédé de gestion de données partagées entre plusieurs unités de traitement, les données étant parties entre au moins un jeu, chaque jeu comprenant au moins une donnée, chaque jeu étant au préalable copié dans un buffer au moyen d’une commande de remplissage, chaque jeu copié étant ensuite utilisé par un traitement et chaque jeu copié et éventuellement modifié par le traitement, étant restitué, à l’issue du traitement, au moyen d’une commande de vidage, où une commande de remplissage et/ou une commande de vidage utilisent un sémaphore univoquement associé à chaque jeu / buffer, pour garantir un unique accès, à un instant donné, à une donnée dudit jeu, où pour une commande de remplissage ou pour une commande de vidage, toutes les mises à jour des différents buffers concernés sont exécutées en parallèle, itérativement jusqu’à ce que toutes les mises à jour soient réalisées.
Des caractéristiques ou des modes de réalisation particuliers, utilisables seuls ou en combinaison, sont :
- le procédé comprend un indicateur de réalisation pour chacun des N buffers associés à une commande de remplissage ou à une commande de vidage et un compteur de réalisation, où le procédé comprend les étapes suivantes : initialisation des indicateurs de réalisation à FAUX, initialisation du compteur à ZERO, initialisation à ZERO de l’indice i, variant de 0 à N-1 , itération, jusqu’à ce que le compteur soit égal à N, en variant l’indice i, des étapes suivantes : si l’indicateur de réalisation courant est FAUX, et si le sémaphore correspondant est disponible, prise du sémaphore, mise à jour du buffer correspondant, libération du sémaphore, mise à VRAI de l’indicateur de réalisation courant, et incrémentation du compteur,
- le procédé comprend encore une étape de mise à jour de buffers non protégés par un sémaphore, réalisée après la mise à jour des buffers protégés par sémaphore,
- la mise à jour de buffers non protégés par un sémaphore, est réalisée lorsque l’indice i vaut une valeur donnée modulo N, préférentiellement ZERO,
- le nombre de sémaphores est configurable,
- le nombre de données est de l’ordre du millier et le nombre de sémaphores est sensiblement égal à 12.
Dans un deuxième aspect, l’invention concerne une application dudit procédé à un contrôle commande de moteur à explosion exécuté sur un processeur multi-cœur.
Brève description des dessins
L’invention sera mieux comprise à la lecture de la description qui suit, faite uniquement à titre d’exemple, et en référence aux figures en annexe dans lesquelles : [Fig. 1] déjà décrite, illustre le principe d’un sémaphore,
[Fig. 2] déjà décrite, illustre le problème de retard d’une tâche en cas de préemption par des interruptions,
[Fig. 3] déjà décrite, illustre le principe de protection des données par buffer,
[Fig. 4] montre un synoptique du procédé selon l’invention.
Description des modes de réalisation
L’invention concerne un procédé de gestion de données échantillonnées partagées entre plusieurs unités de traitement C1, C2. Avantageusement, les données sont parties, elles forment une partition, entre un et avantageusement plusieurs jeux. Un jeu est un ensemble de données permettant un traitement commun, notamment en termes de protection : remplissage, vidage et sémaphore en commun. Chaque jeu comprend au moins une donnée. Afin de protéger les données d’un jeu, préalablement à un traitement, typiquement réalisé par une tâche T1 , T2, un jeu de données, nécessaire à ladite tâche T1 , T2, est copié dans un buffer B1 depuis la mémoire globale MG. Ceci est réalisé par une commande de remplissage FILL1 , typiquement exécutée par la tâche T1 , T2 qui nécessite lesdites données. Ainsi, un jeu copié peut ensuite être utilisé par un traitement ou tâche T1 qui travaille et éventuellement modifie les données ainsi protégées dans ledit buffer B1. A l’issue du traitement, les données du buffer B1 sont restituées au moyen d’une commande de vidage FLUSH1 qui recopie les données du buffer B1 dans la mémoire globale MG.
Afin de ne pas se chevaucher, les différentes commandes de remplissage FILL1 et les différentes commandes de vidage FLUSH1 utilisent au moins un sémaphore SEM1 , un sémaphore SEM1 étant univoquement associé à chaque jeu / buffer B1. Ceci permet de garantir un unique accès, à un instant donné, à une donnée d’un jeu quelconque.
Alors que dans l’art antérieur, une tâche, commande ou traitement rencontrant un sémaphore SEM1 occupé se met en attente DT jusqu’à ce qu’il soit disponible, selon une caractéristique de l’invention, une commande de remplissage FILL, FILL1 ou une commande de vidage FLUSH, FLUSH1 exécute, toutes les mises à jour des différents buffers B1 en parallèle. Ainsi une commande de remplissage ou de vidage lorsqu’elle rencontre un sémaphore SEM1 indisponible, n’attend pas et tente de trouver un autre sémaphore disponible ou libre, et réalise la mise à jour du buffer correspondant lorsqu’un autre sémaphore est trouvé disponible. Ceci est itéré, en repassant sur tous les sémaphores non encore trouvés libres, jusqu’à ce que toutes les mises à jour soient réalisées. Ainsi un sémaphore SEM1 indisponible à un instant donné ne retarde pas le fonctionnement, une autre mise à jour pouvant être réalisée pendant le temps d’attente DT. A charge pour le procédé de revenir tester les sémaphores non encore trouvés libres, pour s’assurer de réaliser la mise à jour de tous les buffers.
Selon un mode de réalisation possible, le procédé peut implémenter cette caractéristique au moyen d’un indicateur de réalisation Fi, i=0 à N-1 , pour chacun des N buffers associés à une commande de remplissage FILL1 ou à une commande de vidage FLUSFI1 et d’un compteur de réalisation CTR. Fi est un indicateur booléen associé à chaque buffer/sémaphore. Il est FAUX ou égal à 0 initialement et tant que le sémaphore associé n’a pas été trouvé libre ou ce qui est équivalent tant que le buffer n’a pas été mis à jour. Il devient VRAI ou égal à 1 lorsque le sémaphore a été trouvé libre et que le buffer a été mis à jour. Le compteur CTR compte le nombre de sémaphores trouvés libres ou ce qui est équivalent le nombre de buffers mis à jour.
Le procédé comprend les étapes suivantes, plus particulièrement illustrées à la figure 4. Une étape d’initialisation est réalisée préalablement. Elle comprend : initialisation de tous les indicateurs de réalisation Fi à FAUX ou 0, initialisation du compteur CTR à ZERO ou 0, et initialisation à ZERO ou 0 d’un indice i, variant de 0 à N-1. Ensuite il est procédé à une itération, jusqu’à ce que le compteur CTR soit égal à N, en variant l’indice i, des étapes suivantes. Si l’indicateur de réalisation courant Fi, est FAUX, et si le sémaphore correspondant SEMi est disponible, prise du sémaphore SEMi, mise à jour du buffer Bi correspondant, libération du sémaphore SEMi, mise à VRAI de l’indicateur de réalisation Fi correspondant à la valeur courante de l’indice i, et incrémentation du compteur CTR. Sinon, si l’indicateur de réalisation Fi courant est VRAI, indiquant un buffer correspondant déjà mis à jour, ou si le sémaphore SEMi courant est indisponible, parce qu’il est pris par un autre traitement, rien n’est fait, la fin de boucle est atteinte et l’itération reprend, pour l’indice i suivant. A noter que l’indice i est incrémenté modulo N et qu’il peut être nécessaire de réaliser un nombre important, nettement supérieur à N, d’itérations.
A titre illustratif, la première itération, suite à l’initialisation, débute avec i=0. Le premier indicateur de réalisation correspondant au premier buffer et à l’indice i=0 est testé. Il est FAUX puisqu’aucune mise à jour n’a encore été réalisée. On suppose ici que le premier sémaphore est indisponible. Il s’ensuit que la branche itérée est terminée. Le test final CTR = N est faux, puisque CTR vaut toujours 0. L’indice i est incrémenté et vaut i=1.
L’indicateur de réalisation F1 correspondant au buffer B1 est testé. Il est FAUX puisqu’aucune mise à jour n’a encore été réalisée. On suppose ici que le sémaphore associé SEM1 est disponible. Aussi, ledit sémaphore SEM1 est pris, le buffer B1 peut être et est mis à jour, puis le sémaphore SEM1 peut être libéré. L’état de mise à jour réussie est acté en changeant l’état de l’indicateur de réalisation F1 de FAUX ou 0 à VRAI ou 1 et en incrémentant le compteur CTR de 1. La branche itérée est terminée. Le test final CTR = N est faux, puisque CTR vaut maintenant 1.
Le procédé se poursuit avec i=2 modulo N, jusqu’à ce que toutes les mises à jour soient réalisées et que le compteur CTR soit en conséquence égal N.
Une donnée n’est pas nécessairement protégée par sémaphore, par exemple lorsqu’elle n’est utilisée que par une unique tâche ou lorsqu’il s’agit d’une donnée atomique. On nomme donnée atomique, une donnée codée sur un longueur lisible par le processeur en un coup d’horloge, tel que par exemple un octet pour un processeur 8 bits. Cependant même ces données non protégées par sémaphore font avantageusement l’objet d’une protection par buffer.
La mise à jour de ces buffers en lecture, FILL, ou en écriture FLUSH, est avantageusement réalisée à l’issue de la mise à jour des buffers protégés par sémaphore, tel qu’illustré à la figure 4, soit après toutes les itérations.
Selon une autre caractéristique alternative, la mise à jour de buffers non protégés par un sémaphore, peut être réalisée au cours de l’itération. Ainsi une fois que les N sémaphores ont été testés, avec ou sans succès, il peut être intéressant d’intercaler tout ou partie de la mise à jour de buffers non protégés par un sémaphore, avant de reboucler sur un nouveau test des sémaphores, principalement lorsque ledit test est négatif, tous les sémaphores restants étant indisponibles. Aussi selon cette caractéristique, tout ou partie de la mise à jour de buffers non protégés par un sémaphore est avantageusement réalisé lorsque l’indice i vaut une valeur donnée modulo N. Cette valeur peut, par exemple, être la valeur ZERO ou 0, rencontrée après un balayage complet de l’ensemble des buffers/sémaphores.
Le nombre de sémaphores est un paramètre délicat à déterminer. Un sémaphore par donnée conduit à un trop grand nombre de sémaphores et à des temps de traitement prohibitifs. Trop peu de sémaphores conduit à contrario à augmenter les temps d’attente DT. Aussi regroupe-t-on avantageusement les données en jeux, chaque jeu étant associé à un sémaphore SEM1. Avantageusement le paramètre nombre de jeux et donc le paramètre nombre de sémaphores est configurable.
Selon une autre caractéristique, pour un nombre de données de l’ordre du millier, un nombre de sémaphores sensiblement égal à 12 apparaît constituer une bonne mesure.
Le procédé selon l’invention est avantageusement appliqué à un contrôle commande de moteur à explosion exécuté sur un processeur multi-cœur, chaque cœur constituant une unité de traitement C1 , C2.
L’invention a été illustrée et décrite en détail dans les dessins et la description précédente. Celle-ci doit être considérée comme illustrative et donnée à titre d’exemple et non comme limitant l’invention à cette seule description. De nombreuses variantes de réalisation sont possibles.
Liste des signes de référence
C1, C2 : unité de traitement, cœur,
T 1 , T2 : tâche,
SEM1, SEMi : sémaphore,
DT : attente,
11, I2, I3, I4 : interruption,
P( ) : prise de sémaphore,
L( ) : libération de sémaphore,
? : interrogation disponibilité sémaphore,
B1 : buffer, MG : mémoire globale,
FO, F1 , Fi : indicateur de réalisation, i : indice, r1 , r2 : lecture d’une donnée, w1 , w2 : écriture d’une donnée,
CTR : compteur de réalisation,
N : nombre de buffers, sémaphores,
FILL, FILL1 : commande de remplissage, FLUSFI, FLUSFI1 : commande de vidage.]

Claims

Revendications
[Revendication 1] [Procédé de gestion de données partagées entre plusieurs unités de traitement (C1 , C2), les données étant parties entre au moins un jeu, chaque jeu comprenant au moins une donnée, chaque jeu étant au préalable copié dans un buffer (B1 ) au moyen d’une commande de remplissage (FILL1 ), chaque jeu copié étant ensuite utilisé par un traitement (T1 ) et chaque jeu copié et éventuellement modifié par le traitement, étant restitué, à l’issue du traitement, au moyen d’une commande de vidage (FLUSH1 ), où une commande de remplissage (FILL1 ) et/ou une commande de vidage (FLUSH1 ) utilisent un sémaphore (SEM1 ) univoquement associé à chaque jeu / buffer (B1 ), pour garantir un unique accès, à un instant donné, à une donnée dudit jeu, caractérisé en ce que pour une commande de remplissage (FILL1 ) ou pour une commande de vidage (FLUSH1 ), toutes les mises à jour des différents buffers (B1 ) concernés sont exécutées en parallèle, itérativement jusqu’à ce que toutes les mises à jour soient réalisées.
[Revendication 2] Procédé selon la revendication 1 , comprenant un indicateur de réalisation (Fi) pour chacun des N buffers (B1 ) associés à une commande de remplissage (FILL1 ) ou à une commande de vidage (FLUSH1 ) et un compteur de réalisation (CTR), où le procédé comprend les étapes suivantes : initialisation des indicateurs de réalisation (Fi) à FAUX, initialisation du compteur (CTR) à ZERO, initialisation à ZERO d’un indice i, variant de 0 à N-1 , itération, jusqu’à ce que le compteur (CTR) soit égal à N, en variant l’indice i, des étapes suivantes : si l’indicateur de réalisation courant (Fi) est FAUX, et si le sémaphore correspondant (SEMi) est disponible, prise du sémaphore (SEMi), mise à jour du buffer correspondant, libération du sémaphore (SEMi), mise à VRAI de l’indicateur de réalisation courant (Fi), et incrémentation du compteur (CTR).
[Revendication 3] Procédé selon la revendication 2, comprenant encore une étape de mise à jour de buffers non protégés par un sémaphore, réalisée après la mise à jour des buffers protégés par sémaphore.
[Revendication 4] Procédé selon la revendication 3, où la mise à jour de buffers non protégés par un sémaphore, est réalisée lorsque l’indice i vaut une valeur donnée modulo N, préférentiellement ZERO.
[Revendication 5] Procédé selon l’une quelconque des revendications précédentes, où le nombre de sémaphores (SEMi) est configurable.
[Revendication 6] Procédé selon l’une quelconque des revendications précédentes, où le nombre de données est de l’ordre du millier et le nombre de sémaphores (SEMi) est sensiblement égal à 12.
[Revendication 7] Application à un contrôle commande de moteur à explosion exécuté sur un processeur multi-cœur.
PCT/EP2021/052546 2020-02-06 2021-02-03 Procede de gestion de donnees echantillonnees partagees entre plusieurs unites de traitement WO2021156308A2 (fr)

Applications Claiming Priority (2)

Application Number Priority Date Filing Date Title
FR2001174 2020-02-06
FR2001174A FR3107130B1 (fr) 2020-02-06 2020-02-06 Procédé de gestion de données échantillonnées partagées entre plusieurs unités de traitement

Publications (1)

Publication Number Publication Date
WO2021156308A2 true WO2021156308A2 (fr) 2021-08-12

Family

ID=70804709

Family Applications (1)

Application Number Title Priority Date Filing Date
PCT/EP2021/052546 WO2021156308A2 (fr) 2020-02-06 2021-02-03 Procede de gestion de donnees echantillonnees partagees entre plusieurs unites de traitement

Country Status (2)

Country Link
FR (1) FR3107130B1 (fr)
WO (1) WO2021156308A2 (fr)

Family Cites Families (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
WO2003042810A1 (fr) * 2001-11-13 2003-05-22 Koninklijke Philips Electronics N.V. Operation de semaphore p et v

Also Published As

Publication number Publication date
FR3107130A1 (fr) 2021-08-13
FR3107130B1 (fr) 2022-05-06

Similar Documents

Publication Publication Date Title
US10860457B1 (en) Globally ordered event stream logging
EP1043658B1 (fr) Procédé d'amélioration des performances d'un système multiprocesseur comprenant une file d'attente de travaux et architecture de système pour la mise en oeuvre du procédé
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
EP0109898B1 (fr) Unité de stockage temporaire de données organisée en file d'attente
CN112204513A (zh) 多租户存储系统中的基于组的数据复制
EP3123344B1 (fr) Procede de transfert de donnees entre taches temps reel utilisant un controleur memoire dma
FR3025908A1 (fr) Mecanisme et procede pour acceder a des donnees dans une memoire partagee
EP0029131A1 (fr) Procédé de commande de l'affectation de ressources dans un système comportant plusieurs processeurs à fonctionnement simultané
FR3025907B1 (fr) Mecanisme et procede pour permettre une communication entre un client et un serveur en accedant a des donnees de messages en memoire partagee.
KR20080038301A (ko) 차단 로컬 센스 동기화 배리어
CN111881116A (zh) 数据迁移方法、数据迁移系统、计算机系统和存储介质
EP0515238B1 (fr) Dispositif et méthode pour la gestion de plusieurs files d'attente indépendantes dans un espace mémoire commun et banalisé
FR3101987A1 (fr) Procédé de simulation parallèle reproductible de niveau système électronique mis en œuvre au moyen d'un système informatique multi-cœurs de simulation à événements discrets
EP4006730A1 (fr) Procédé de simulation parallèle reproductible de niveau système électronique mis en oeuvre au moyen d'un système informatique multi-coeurs de simulation à évènements discrets
EP0646875A1 (fr) Procédé et système d'interconnexion pour la gestion de messages dans un réseau de processeurs à structure parallèle
EP2726985B1 (fr) Dispositif et procede de synchronisation de taches executees en parallele sur une plateforme comprenant plusieurs unites de calcul
WO2021156308A2 (fr) Procede de gestion de donnees echantillonnees partagees entre plusieurs unites de traitement
WO2024001025A1 (fr) Procédé de nettoyage de données en mémoire cache de pré-exécution et nœud de chaîne de blocs
WO2012038000A1 (fr) Procede de gestion de taches dans un microprocesseur ou un ensemble de microprocesseurs
US11966725B2 (en) Microservice termination while maintaining high availability
FR2503900A1 (fr) Dispositif de reprise pour installation de traitement de donnees
WO2024108348A1 (fr) Procédé et système de cohérence à terme de types de données dans des systèmes de base de données actifs-actifs géo-distribués
US20220164282A1 (en) Reducing load balancing work stealing
WO2020016511A1 (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
FR3087982A1 (fr) Procede et circuit de multiplexage temporel d'acces concurrents a une ressource informatique

Legal Events

Date Code Title Description
NENP Non-entry into the national phase

Ref country code: DE