FR 3145631 A1 20240809 FR 2300953 A 20230202 Procédé mis en œuvre par ordinateur de gestion de données partagées, dans lequel une variable VAR est accessible par plusieurs tâches TASK_i exécutées en parallèle. Une variable de priorité PRIO_DATA est associée à la variable VAR. Une constante de priorité PRIO_ i caractérise l’ordre de priorité de la tâche TASK_i. À un instant t1 la tâche TASK_i utilise la valeur de la variable VAR partagée. Si PRIO_i> PRIO_DATA alors PRIO_DATA est mis à jour à la valeur PRIO_i. Après l’exécution de la même tâche TASK_i à un instant t2>t1, la tâche TASK_i génère une valeur VAR_UPDATE_i de la variable VAR. Si PRIO_DATA à l’instant t2 = PRIO_i, alors VAR est mis à jour à la valeur VAR_UPDATE_i et PRIO_DATA est mis à jour à la valeur une valeur initiale. Un dispositif informatique et un support d'enregistrement non transitoire lisible par ordinateur sont aussi présentés. Figure de l’abrégé : Figure 6. PROCEDE DE GESTION DE DONNEES PARTAGEES La présente divulgation relève du domaine des tâches logicielles effectuées en parallèle. Les processeurs multicœurs permettent l'exécution parallèle de plusieurs tâches logicielles. L’exécution de tâches logicielles en parallèle est par exemple utile dans le domaine des systèmes embarqués. Le temps de réponse des tâches logicielles est un élément important afin d'assurer un comportement fonctionnel correct (par exemple le contrôle d'un moteur à combustion) et la sécurité (par exemple la coupure d'injection pour les moteurs à combustion doit être très rapide pour garantir la sécurité du conducteur). Les tâches logicielles (ou fonctions) comportent typiquement un ou plusieurs algorithmes appelés exécutables (ou runnables en anglais) qui sont exécutés lorsque la tâche est elle-même déclenchée par un événement (e.g. événement lié à la position du moteur) des signaux temporels. Une même variable peut être utilisée par plusieurs exécutables qui sont exécutés à des temps différents, parfois en parallèle, et la valeur de la variable peut évoluer dans le temps en fonction de sa valeur déterminée à la fin de chaque exécutable. Dans certains cas, la variable peut être même mise instantanément à disposition d’autres exécutables dès que modifiée. La production d'une donnée basée sur cette variable peut alors conduire à des accès concurrents à la variable si elle est en lecture/écriture à partir de tâches concurrentes (par exemple des tâches concurrentes exécutées dans différents cœurs, chaque tâche ayant un ou plusieurs exécutables). Des problèmes de Last Writer Win (LWW) peuvent alors survenir lorsqu’il y a un chevauchement entre les accès en lecture et en écriture de la variable. Ceci peut conduire à perdre la valeur de la variable calculée par une tâche au profit d’une autre tâche concurrente. Résumé La présente divulgation vient améliorer la situation. Il est proposé un procédé mis en œuvre par ordinateur de gestion de données partagées au travers d’une mémoire, dans lequel une variable VAR partagée est enregistrée dans la mémoire, la variable VAR est accessible par au moins deux tâches TASK_i (i=1…n, n>=2) exécutées en parallèle les unes des autres, chaque tâche TASK_i comprenant au moins un exécutable RUN_ij (j=1…k, k>=1), lorsque la tâche TASK_i comprend au moins deux exécutables RUN_ij ceux-ci sont exécutés séquentiellement, une variable de priorité PRIO_DATA associée à la variable VAR étant stockée dans la mémoire et prenant initialement une valeur PRIO_INI, une constante de priorité PRIO_i étant stockée dans la mémoire pour chacune des tâches TASK_i, la constante de priorité PRIO_i caractérisant l’ordre de priorité de la tâche TASK_i, PRIO_INI étant réservée à la priorité la plus faible et étant différente de chacune des constantes de priorité PRIO_i, chacun des exécutables RUN_ij ayant une constante de priorité PRIO_RUN_ij associée caractérisant l’ordre de priorité de l’exécutable RUN_ij produisant la variable VAR, pour chacune des tâches TASK_i la constante de priorité PRIO_ i de la tâche TASK_i étant le maximum des constantes de priorité PRIO_RUN_ij des exécutables RUN_ij de cette tâche, le procédé comprenant les étapes suivantes: - à un instant t1 : * initier la i-ième tâche TASK_i en utilisant la valeur de la variable VAR partagée à t1 dans la mémoire, et * si PRIO_i> PRIO_DATA à l’instant t1 alors PRIO_DATA est mis à jour à la valeur PRIO_i, - après l’exécution de la même i-ième tâche TASK_i à un instant t2>t1, la i-ième tâche TASK_i génère une valeur VAR_UPDATE_i de la variable VAR, * si PRIO_DATA à l’instant t2 = PRIO_i, alors VAR est mis à jour à la valeur VAR_UPDATE_i et PRIO_DATA est mis à jour à la valeur PRIO_INI. Le procédé de gestion de données partagées peut avoir une ou plusieurs des caractéristiques suivantes : * les valeurs de chaque PRIO_i sont strictement croissantes suivant l’ordre de priorité de la tâche TASK_i produisant la variable VAR, PRIO_INI étant plus petite que chacune des constantes de priorité PRIO_i, préférentiellement PRIO_INI=0. * chacune des tâches TASK_i est exécutée sur un cœur CORE_i qui lui est propre. * le procédé comprend de plus un premier tampon BUFF_1 disposé entre la mémoire et un premier cœur CORE_1 sur lequel est exécutée une première tâche TASK_1, et/ou un deuxième tampon BUFF_2 disposé entre la mémoire et un deuxième cœur CORE_2 sur lequel est exécutée une deuxième tâche TASK_2, les premier et deuxième tampons BUFF_1, BUFF_2 comprenant des copies des valeurs des variables VAR utilisées par les tâches TASK_1, TASK2 en entrée et sortie des tâches TASK_1, TASK2, les premier et deuxième tampons BUFF_1, BUFF_2 pouvant interagir avec la mémoire pour modifier la variable VAR en sortie des tâches TASK_i. * les premier et deuxième tampons BUFF_1, BUFF_2 comprenant des copies des valeurs des variables VAR en entrée et sortie des exécutables RUN_1j, RUN_2j de chacune des tâches TASK_1, TASK2. * la création de la constante de priorité PRIO_i est faite hors ligne. * la mémoire est une mémoire vive, notamment une mémoire RAM (random access memory). Selon un autre aspect, il est proposé un programme informatique comportant des instructions pour la mise en œuvre de tout ou partie d’un procédé tel que défini dans les présentes lorsque ce programme est exécuté par un processeur. Selon un autre aspect, il est proposé un support d’enregistrement non transitoire, lisible par un ordinateur, sur lequel est enregistré un tel programme. Selon un autre aspect, il est proposé un dispositif informatique comprenant : une mémoire pour stocker au moins des instructions le programme informatique de la revendication précédente, et un processeur accédant à la mémoire pour lire les instructions précitées et exécuter ensuite le procédé ci-dessus. Selon un autre aspect, il est proposé un support d'enregistrement non transitoire lisible par ordinateur sur lequel un programme informatique est enregistré pour mettre en œuvre le procédé ci-dessus, lorsque le programme informatique est exécuté par un processeur. Selon un autre aspect, il est proposé un véhicule avec un système embarqué comportant le dispositif informatique ci-dessus. D’autres caractéristiques, détails et avantages apparaîtront à la lecture de la description détaillée ci-après, et à l’analyse des dessins annexés, sur lesquels : Fig. 1 montre un exemple de variable partagée sur lequel il existe un problème de LWW. Fig. 2 montre un autre exemple de variable partagée sur lequel il existe un problème de LWW. Fig. 3 montre encore un autre exemple de variable partagée sur lequel il existe un problème de LWW. Fig. 4 montre un exemple d’attribution de priorité entre plusieurs tâches ayant chacune un ou plusieurs exécutables. Fig. 5 montre un ordinogramme de gestion de priorité entre plusieurs tâches utilisant une variable partagée. Fig. 6 montre un premier exemple de gestion de priorité entre deux tâches concurrentes utilisant une variable partagée. Fig. 7 montre un deuxième exemple de gestion de priorité entre deux tâches concurrentes utilisant une variable partagée. Fig. 8 montre un troisième exemple de gestion de priorité entre deux tâches concurrentes utilisant une variable partagée. Fig. 9 montre un quatrième exemple de gestion de priorité entre deux tâches concurrentes utilisant une variable partagée. Fig. 10 montre un cinquième exemple de gestion de priorité entre deux tâches concurrentes utilisant une variable partagée. Fig. 11 montre un sixième exemple de gestion de priorité entre deux tâches concurrentes utilisant une variable partagée. Fig. 12 montre un exemple de gestion de priorité entre deux tâches non concurrentes utilisant une variable partagée. Il est maintenant fait référence aux figures 1 et 2 qui illustrent des cas de figures où des problèmes de Last Writer Win (LWW) peuvent alors survenir. Un cœur CORE1 contient une tâche TASK A qui contient un exécutable RUNNABLE A. Un cœur CORE 2 en parallèle du cœur CORE1 contient une tâche TASK B qui contient un exécutable RUNNABLE B. Chaque exécutable RUNNABLE A, RUNNABLE B accède à une variable VAR en début d’exécution et mettent à jour la valeur de la variable VAR avec la valeur qu’ils ont calculée, en fin d’exécution. Les exécutables RUNNABLE A, RUNNABLE B accèdent et mettent à jour la variable VAR à des instants différents. Ainsi, pour le cas de la , la variable VAR est accédée d’abord par l’exécutable RUNNABLE A, puis par l’exécutable RUNNABLE B. L’exécutable RUNNABLE B se termine avant l’exécutable RUNNABLE A, et la valeur de la variable VAR est donc mise à jour séquentiellement par l’exécutable RUNNABLE B puis l’exécutable RUNNABLE A. Ainsi, lorsque les tâches TASK A et TASK B sont accomplies, la variable a la valeur de mise à jour par la tâche TASK A. Dans le cas inverse, à la , l’exécutable RUNNABLE A se termine avant l’exécutable RUNNABLE B, et la valeur de la variable VAR est donc mise à jour séquentiellement par l’exécutable RUNNABLE A puis l’exécutable RUNNABLE B. Ainsi, lorsque les tâches TASK A et TASK B sont accomplies, la variable a la valeur de mise à jour par la tâche TASK B. On voit donc que la priorité des tâches TASK A et TASK B n’est pas définie par leur priorité intrinsèque mais est déterminé par leur temporalité. Il peut donc survenir un problème de Last Writer Win (LWW) sur la valeur de la variable VAR puisque ce sera le dernier exécutable à mettre à jour la valeur de la variable VAR qui déterminera la valeur de la variable VAR lorsque les tâches TASK A et TASK B sont accomplies. En référence à la , le cas de la est maintenant illustré avec des mémoire tampons, ou buffers, BUF1, BUF2, interagissant respectivement entre la mémoire contenant la variable VAR et les tâches TASK A et TASK B. Les tampons BUF1, BUF2 sont utilisés afin d'assurer la cohérence des données accédées dans des tâches simultanées (généralement à partir de différents cœurs). Un mécanisme de mise en mémoire tampon est couramment utilisé pour assurer la stabilité d'une variable lue plusieurs fois dans une tâche et écrite dans d'autres tâches concurrentes, et la cohérence d'un ensemble de variables qui sont lues dans une tâche et écrites dans d'autres tâches simultanées. Les tampons BUF1, BUF2 sont créés sur chaque tâche simultanée TASK A et TASK B. Des routines FILL et FLUSH sont générées pour gérer les accès aux données en mémoire globale, et notamment la variable VAR, et pour remplir et vider les tampons (lecture et écriture). L'accès simultané de ces routines FILL et FLUSH à la mémoire globale est évité par l'utilisation de sémaphores. Routine FILL : sous le sémaphore, elle copie les données de la mémoire globale vers le tampon local (consigne de remplir le tampon). Routine FLUSH : sous le sémaphore, elle copie le tampon local vers les données de la mémoire globale (consigne de vider le tampon). On remarque que l’utilisation des tampons accentue le problème LWW sur la variable VAR car il augmente la temporalité entre les accès en lecture et en écriture effectués dans des tâches concurrentes pour cette variable. Au lieu que la lecture et l’écriture se fassent au moment de l’exécution de l’exécutable, celles-ci se font lorsque la mémoire tampon est vidée, quelques instants après la fin de l’exécutable. Ainsi, dans le cas de la , la variable VAR mise à jour par l’exécutable RUNNABLE A n’est pas mise à jour en fin d’exécution du RUNNABLE A comme dans le cas de la , mais au moment de vider le tampon BUF1. En réponse à ces cas de figure, un procédé de gestion de priorités est proposé. L'invention consiste à gérer certaines priorités pour des variables, optionnellement tamponnées, partagées qui pourraient être écrasées par des tâches concurrentes. Pour éviter la situation du LWW, un ordre de priorité est géré pour chaque variable partagée associée aux tâches concurrentes. Le procédé consiste essentiellement en 2 étapes. La première étape se fait lors de la conception de l'algorithme et consiste à attribuer/déterminer les ordres de priorité des tâches (et des exécutables). Cette première étape peut être réalisée hors ligne (off line) ou en temps réel. La seconde est effectuée dynamiquement, lors de l'exécution des exécutables, et consiste à attribuer une valeur de la variable VAR en temps réel en fonction des priorités des exécutables/tâches. En référence maintenant à la , la première étape correspondant à l’attribution des ordres de priorité va être décrite. Dans un cas général à n tâches exécutées TASK_i (i=1…n, n>=2) en parallèle ayant chacune j exécutables RUN_ij (j=1…k, k>=1), la variable VAR partagée est enregistrée dans la mémoire et est accessible par les tâches TASK_i exécutées en parallèle. Selon un mode de réalisation, chacune des tâches TASK_i est exécutée sur un cœur CORE_i qui lui est propre. La mémoire sur laquelle la variable VAR est enregistrée est par exemple une mémoire vive, notamment une mémoire RAM (random access memory). Chaque tâche TASK_i comprend au moins un exécutable RUN_ij. Lorsque la tâche TASK_i comprend deux ou plus exécutables RUN_ij ceux-ci sont exécutés séquentiellement. Une constante de priorité PRIO_i est stockée dans la mémoire pour chacune des tâches TASK_i. La constante de priorité PRIO_i caractérise l’ordre de priorité de la tâche TASK_i produisant la variable VAR. Une constante PRIO_INI est réservée à la priorité la plus faible et est différente de chacune des constantes de priorité PRIO_i. Chacun des exécutables RUN_ij a une constante de priorité PRIO_RUN_ij associée. La constante de priorité PRIO_RUN_ij caractérise l’ordre de priorité de l’exécutable RUN_ij produisant la variable VAR. Pour chacune des tâches TASK_i la constante de priorité PRIO_i de la tâche TASK_i est le maximum des constantes de priorité PRIO_RUN_ij des exécutables RUN_ij de cette tâche. Ainsi si on se réfère au cas particulier de la , la tâche TASK A est exécutée en parallèle de la tâche TASK B. La tâche TASK A comprend deux exécutables RUNNABLE 1 et RUNNABLE 2 qui s’exécutent séquentiellement. La tâche TASK B comprend un exécutable RUNNABLE 3. Chaque exécutable RUNNABLE 1, RUNNABLE 2, RUNNABLE 3 a une constante de priorité PRIO_RUN_A1, PRIO_RUN_A2, PRIO_RUN_B3 associée. Afin de déterminer la priorité globale de la tâche TASK A par rapport à la tâche TASK B, la constante de priorité PRIO A de la tâche TASK A est le maximum des constantes de priorité PRIO_RUN_A1, PRIO_RUN_A2 des exécutables RUNNABLE 1, RUNNABLE 2 de cette tâche. Pour la tâche TASK B, la constante de priorité PRIO B est simplement la constante de priorité PRIO_RUN_B3 de l’exécutable RUNNABLE 3, puisque cette tâche ne comporte pas d’autre exécutable que RUNNABLE 3. Aucune des constantes de PRIO A, PRIO B a la valeur de la constante d’initiation PRIO_INI réservée à la priorité la plus faible. Les constantes de priorité sont, selon un mode de réalisation, positives et strictement croissantes. Selon un mode de réalisation, PRIO_INI=0. Ainsi donc, pour la gestion ultérieure de la priorité de la tâche TASK A par rapport à la tâche TASK B, les constantes PRIO A et PRIO B seront comparées. Si PRIO A> PRIO B alors, la tâche TASK A sera prioritaire sur la tâche TASK B pour la production de la variable VAR. Et si PRIO B> PRIO A alors, la tâche TASK B sera prioritaire sur la tâche TASK A pour la production de la variable VAR. En référence maintenant à la , la deuxième étape correspondant à l’attribution en temps réel d’une valeur de la variable VAR en fonction des ordres de priorité des tâches TASK A, TASK B va être décrite. À l’étape S1, à un instant t1, la i-ième tâche TASK_i ayant la priorité PRIO_i est initiée en utilisant la valeur de la variable VAR partagée à t1 dans la mémoire (lecture de la variable VAR par la tâche TASK_i), et si PRIO_i> PRIO_DATA à l’instant t1 (c’est-à-dire que la priorité de la tâche TASK_i est supérieure à celle en cours à l’instant t1, voir flèche « Y » sur la ) alors PRIO_DATA est mis à jour à la valeur PRIO_i (c’est-à-dire que la nouvelle priorité est la priorité de tâche TASK_i). L’instant t1 de lecture de la variable VAR peut être l’instant d’initiation d’exécution de la tâche ou un instant antérieur, comme par exemple l’instant de remplissage du tampon (routine FILL) si un tampon est utilisé. À l’étape S2, après l’exécution de la même i-ième tâche TASK_i à un instant t2>t1, la i-ième tâche TASK_i génère une valeur VAR_UPDATE_i de la variable VAR, si PRIO_DATA à l’instant t2 = PRIO_i (voir flèche « Y » sur la ), alors VAR est mis à jour à la valeur VAR_UPDATE_i et PRIO_DATA est mis à jour à la valeur PRIO_INI (écriture dans la mémoire de la variable VAR calculée par la tâche TASK_i). L’instant t2 d’écriture de la variable VAR peut être l’instant de fin d’exécution de la tâche ou un instant postérieur, comme par exemple l’instant de vidange de tampon (routine FLUSH) si un tampon est utilisé. Différents cas applicables de la deuxième étape vont être illustrés en référence aux figures 6 à 12 pour le cas de la où le cœur CORE A contient une tâche TASK A avec deux exécutables RUNNABLE 1, RUNNABLE 2, et le cœur CORE B parallèle au cœur CORE A contient une tâche TASK B avec un exécutable RUNNABLE 3. Par soucis de cohérence avec une numérotation numérique telle qu’utilisée dans la définition de l’algorithme, dans les figures 6 à 12, le cœur CORE A sera identifié par CORE_1, la tâche TASK A par tâche TASK_1, et les exécutables de la tâche TASK_1 seront RUN_11 et RUN_12. De même, le cœur CORE B sera identifié par CORE_2, la tâche TASK B par tâche TASK_2, et l’exécutable de la tâche TASK_2 seront RUN_21. Les figures 6 à 12 illustrent un mode de réalisation où des tampons BUFF_1, BUFF_2 (similaires aux tampons BUF1, BUF2 de la ) sont présents. Il se pourrait cependant qu’il n’y ait qu’un ou pas de tampons. Les instants de lecture et d’écriture de la variable VAR correspondent au remplissage (routine FILL) et à la vidange (routine FLUSH) du tampon lorsque des tampons sont présents. Si les tampons ne sont pas présents, instants de lecture et d’écriture de la variable VAR peuvent être les instants de début et fin des taches. Dans le cas de la , il est défini que la priorité PRIO_2 de la tâche TASK_2 est plus importante que la priorité PRIO_1 de la tâche TASK_1. Initialement dans la mémoire RAM, la variable PRIO_DATA est à 0 (car dans ce cas particulier, il a donc été choisi que PRIO_INI=0). La tâche TASK_1 commence avant la tâche TASK_2. Lorsque la tâche TASK_1 commence à l’instant t1, la priorité de la tâche TASK_1 est comparée à la valeur de la variable PRIO_DATA à cet instant. Comme PRIO_DATA=0, PRIO_1>PRIO_DATA et donc PRIO_DATA est mis à jour avec la valeur PRIO_1. L’étape S1 décrite ci-dessus vient d’être accomplie. Simultanément, la variable VAR qui est à x à cet instant est recopiée dans le tampon BUFF_1. Le premier exécutable RUN_11 de la tâche TASK_1 est initié avec la valeur x de la variable VAR recopiée dans le tampon BUFF_1 à cet instant. Lorsque le premier exécutable RUN_11 se termine, il produit une valeur x1 mise à jour de la variable VAR, qui est recopiée dans le tampon BUFF_1, mais pas dans la mémoire car le tampon BUFF_1 n’est pas encore instruit de se vidanger. Lorsque le deuxième exécutable RUN_12 de la tâche TASK_1 est initié, il prend la valeur x1 de la variable VAR disponible dans le BUFF_1 à cet instant. Lorsque le deuxième exécutable RUN_12 se termine, il produit une valeur x2 mise à jour de la variable VAR, qui est recopiée dans le tampon BUFF_1. Il n’y a pas d’autres exécutables dans ce tampon. Une gestion de la priorité conformément à l’étape S2 se passe à la vidange du tampon BUFF_1 afin de déterminer si la valeur x2 de la variable VAR peut être recopiée dans la mémoire pour être utilisée par d’autres tâches. À l’instant t2 (qui est l’instant de vidange du tampon BUFF_1), la priorité PRIO_1 de la tâche TASK_1 est comparée à PRIO_DATA. Si PRIO_DATA=PRIO_1, cela veut dire qu’aucune autre tâche concurrente de plus haute priorité a été initiée entre les instants t1 et t2. Dans ce cas-là, la valeur x2 de la variable VAR peut être recopiée dans la mémoire. Mais ceci n’est pas le cas de la , où la tâche TASK_2 de priorité PRIO_2 plus importante a été initiée à un instant t3 compris entre t1 et t2. Ainsi, à l’instant t2, PRIO_DATA n’est plus PRIO_1, et donc la valeur x2 de la variable VAR n’est pas recopiée dans la mémoire et reste dans le tampon BUFF_2. Dans le cas de la , à l’instant t2, PRIO_DATA a la valeur de PRIO_INI (c’est-à-dire 0) car à l’instant t2 la tâche TASK_2 est déjà achevée (à t4 compris entre t1 et t2). Si la tâche TASK_2 n’était pas déjà achevée, PRIO_DATA aurait la valeur PRIO_2, et le résultat pour le recopiage ou non de la variable x2 serait le même puisque à l’instant t2, PRIO_DATA n’est toujours pas PRIO_1. La gestion de la priorité du point de vue de la tâche TASK_2 est aussi gérée par les étapes S1 et S2. Ainsi, à l’étape S1, à l’instant t3, la variable VAR a la valeur x et PRIO_DATA a la valeur PRIO_1. PRIO_DATA est comparé à PRIO_2. Comme PRIO_2> PRIO_1, la tâche TASK_2 prend la priorité sur la tâche TASK_1 pour la gestion de la variable VAR et PRIO_DATA est mis à jour avec la valeur PRIO_2. La valeur x de la variable VAR est recopiée dans le tampon BUFF_2. L’exécutable RUN_21 de la tâche TASK_2 est initié avec la valeur x de la variable VAR recopiée dans le tampon BUFF_2. Lorsque l’exécutable RUN_21 se termine, il produit une valeur y mise à jour de la variable VAR, qui est recopiée dans le tampon BUFF_2. Une gestion de la priorité conformément à l’étape S2 se passe alors, afin de déterminer si la valeur y de la variable VAR peut être recopiée dans la mémoire afin d’être utilisée par d’autres tâches. À l’instant t4 (qui est l’instant de vidange du tampon BUFF_2), la priorité PRIO_2 de la tâche TASK_2 est comparée à PRIO_DATA. Si PRIO_DATA=PRIO_2, cela veut dire qu’aucune autre tâche concurrente de plus haute priorité n’a été initiée entre les instants t3 et t4. Dans ce cas-là, la valeur y de la variable VAR peut être recopiée dans la mémoire. Mais ce n’est pas le cas de la , où la tâche TASK_2 est la tâche de priorité PRIO_2 la plus importante. Ainsi, à l’instant t4, PRIO_DATA est toujours PRIO_2, et donc la valeur y de la variable VAR est recopiée dans la mémoire, et PRIO_DATA est réinitialisée à PRIO_INI. Cette valeur restera même en fin d’exécution de la tâche TASK_1, ce qui traduit bien le fait que la tâche TASK_2 est prioritaire pour la valeur de la variable VAR sur la tâche TASK_1 lorsque la tâche TASK_1 vient temporellement en concurrence de la tâche TASK_2. La présente un cas de figure similaire à celui de la , excepté que la priorité PRIO_1 de la tâche TASK_1 est supérieure à la priorité PRIO_2 de la tâche TASK_2. Ainsi, au niveau de la tâche TASK_1, à l’instant t1, la valeur x de la variable VAR est recopiée dans le tampon BUFF_1. En ce qui concerne PRIO_DATA, à l’instant t1 PRIO_DATA = 0, donc PRIO_DATA En ce qui concerne la gestion de la priorité au niveau de la tâche TASK_2, à l’instant t3, la valeur x de la variable VAR est recopiée dans le tampon BUFF_2. En ce qui concerne PRIO_DATA, à l’instant t3 PRIO_DATA = PRIO_1, donc PRIO_DATA > PRIO_2, et de ce fait PRIO_DATA n’est pas mis à jour avec la valeur PRIO_2. À l’instant t4 de vidange du tampon BUFF_2 de la tâche TASK_2, PRIO_DATA est toujours égal à PRIO_1, et la valeur y obtenue en fin du deuxième exécutable RUN_21 n’est pas recopiée dans la mémoire pour devenir la nouvelle valeur de la variable VAR. La valeur de VAR en fin d’exécution de la tâche TASK_1 sera la valeur x2 de la tâche TASK_1, ce qui traduit bien le fait que la tâche TASK_1 est prioritaire pour la valeur de la variable VAR sur la tâche TASK_2 lorsque la tâche TASK_2 vient temporellement en concurrence de la tâche TASK_1. Dans le cas de la , la priorité PRIO_2 de la tâche TASK_2 est plus importante que la priorité PRIO_1 de la tâche TASK_1 comme dans le cas de la . Par contre, contrairement au cas de la , la tâche TASK_2 est initiée temporellement avant la tâche TASK_1. La gestion des priorités est donc comme suit en appliquant les étapes S1 et S2 : En ce qui concerne la gestion de la priorité au niveau de la tâche TASK_1, à l’instant t1 qui est postérieur à t3, la valeur x de la variable VAR est recopiée dans le tampon BUFF_1. La valeur de la variable VAR n’a pas été modifiée à cet instant par la tâche TASK_2 puisque celle-ci n’est pas encore terminée à l’instant t1. En ce qui concerne PRIO_DATA, à l’instant t1 PRIO_DATA = PRIO_2. Comme PRIO_1 En ce qui concerne la gestion de la priorité au niveau de la tâche TASK_2, à l’instant t3, la valeur x de la variable VAR est recopiée dans le tampon BUFF_2. En ce qui concerne PRIO_DATA, à l’instant t3 PRIO_DATA = PRIO_INI (=0), donc PRIO_DATA Cette valeur restera la même en fin d’exécution de la tâche TASK_1, ce qui traduit bien le fait que la tâche TASK_2 est prioritaire pour la valeur de la variable VAR sur la tâche TASK_1 lorsque la tâche TASK_1 vient temporellement en concurrence de la tâche TASK_2. Le cas de la est similaire à celui de la , excepté que la priorité PRIO_1 de la tâche TASK_1 est plus importante que la priorité PRIO_2 de la tâche TASK_2. La gestion des priorités est donc comme suit en appliquant les étapes S1 et S2 : En ce qui concerne la gestion de la priorité au niveau de la tâche TASK_1, à l’instant t1 qui est postérieur à t3, la valeur x de la variable VAR est recopiée dans le tampon BUFF_1. En ce qui concerne PRIO_DATA, à l’instant t1 PRIO_DATA = PRIO_2. Comme PRIO_1 > PRIO_DATA, PRIO_DATA est mis à jour avec la valeur PRIO_1, car la tâche TASK_1 est prioritaire sur la tâche TASK_2. À l’instant t2 de vidange du tampon BUFF_1 de la tâche TASK_1, PRIO_DATA a toujours la valeur de PRIO_1. La valeur x2 obtenue en fin du deuxième exécutable RUN_12 est donc recopiée dans la mémoire pour devenir la nouvelle valeur de la variable VAR, et PRIO_DATA est réinitialisé à PRIO_INI. En ce qui concerne la gestion de la priorité au niveau de la tâche TASK_2, à l’instant t3, la valeur x de la variable VAR est recopiée dans le tampon BUFF_2. En ce qui concerne PRIO_DATA, à l’instant t3 PRIO_DATA = PRIO_INI (=0), donc PRIO_DATA La valeur de VAR en fin d’exécution des tâches TASK_1 et TASK_2 est la valeur en fin d’exécution de la tâche TASK_1, ce qui traduit bien le fait que la tâche TASK_1 est prioritaire pour la valeur de la variable VAR sur la tâche TASK_2 lorsque la tâche TASK_1 vient temporellement en concurrence de la tâche TASK_2. Dans le cas de la , la priorité PRIO_2 de la tâche TASK_2 est plus importante que la priorité PRIO_1 de la tâche TASK_1, et la tâche TASK_2 commence temporellement après la tâche TASK_1 comme dans le cas de la . Par contre, contrairement au cas de la , la tâche TASK_2 se termine temporellement après la tâche TASK_1 au niveau des tampons. La gestion des priorités est donc comme suit en appliquant les étapes S1 et S2 : En ce qui concerne la gestion de la priorité au niveau de la tâche TASK_1, à l’instant t1, la valeur x de la variable VAR est recopiée dans le tampon BUFF_1. En ce qui concerne PRIO_DATA, à l’instant t1 PRIO_DATA = PRIO_INI (=0). Comme PRIO_1 > PRIO_DATA, PRIO_DATA est mis à jour avec la valeur PRIO_1. À l’instant t2 de vidange du tampon BUFF_1 de la tâche TASK_1, PRIO_DATA = PRIO_2 (comme la tâche TASK_2 est initiée après tâche TASK_1 et qu’elle est prioritaire sur la tâche TASK_1), et la valeur x2 obtenue en fin du deuxième exécutable RUN_12 n’est pas recopiée dans la mémoire pour devenir la nouvelle valeur de la variable VAR. En ce qui concerne la gestion de la priorité au niveau de la tâche TASK_2, à l’instant t3 postérieur à t1 et antérieure à t2 instant de remplissage de tampon BUFF_2 de la tâche TASK_2, la valeur x de la variable VAR est recopiée dans le tampon BUFF_2. En ce qui concerne PRIO_DATA, à l’instant t3 PRIO_DATA = PRIO_1, donc PRIO_DATA Ainsi, la valeur de la variable VAR en fin d’exécution des tâches TASK_1 et TASK_2 est la valeur de la variable VAR en fin d’exécution de la tâche TASK_2, ce qui traduit bien le fait que la tâche TASK_2 est prioritaire pour la valeur de la variable VAR sur la tâche TASK_1 lorsque la tâche TASK_1 vient temporellement en concurrence de la tâche TASK_2. Le cas de la est similaire à celui de la , excepté que la priorité PRIO_1 de la tâche TASK_1 est plus importante que la priorité PRIO_2 de la tâche TASK_2. La gestion des priorités est donc comme suit en appliquant les étapes S1 et S2 : En ce qui concerne la gestion de la priorité au niveau de la tâche TASK_1, à l’instant t1, la valeur x de la variable VAR est recopiée dans le tampon BUFF_1. En ce qui concerne PRIO_DATA, à l’instant t1 PRIO_DATA = PRIO_INI = 0. Comme PRIO_1 > PRIO_DATA, PRIO_DATA est mis à jour avec la valeur PRIO_1. À l’instant t2 de vidange du tampon BUFF_1 (après exécution de la tâche TASK_1), PRIO_DATA a toujours la valeur de PRIO_1, car même si la tâche TASK_2 a été initiée à t3 entre t1 et t2, sa priorité est plus faible, et PRIO_DATA n’a pas été mis à jour. La valeur x2 obtenue en fin du deuxième exécutable RUN_12 est recopiée à t4 dans la mémoire pour devenir la nouvelle valeur de la variable VAR, et PRIO_DATA est réinitialisé à PRIO_INI. En ce qui concerne la gestion de la priorité au niveau de la tâche TASK_2, à l’instant t3, la valeur x de la variable VAR est recopiée dans le tampon BUFF_2. En ce qui concerne PRIO_DATA, à l’instant t3 PRIO_DATA = PRIO_1, donc PRIO_DATA > PRIO_2 car la tâche TASK_1 est prioritaire sur la tâche TASK_2, et de ce fait PRIO_DATA n’est pas mis à jour à t3 avec la valeur PRIO_2. À l’instant t4 de de vidange du tampon BUFF_2 (après exécution de la tâche TASK_2), PRIO_DATA a été mise à jour à PRIO_INI=0 à t2. Comme à t4, PRIO_DATA n’est pas PRIO_2, la valeur y de la variable VAR obtenue en fin du deuxième exécutable RUN_21 de la tâche TASK_2 n’est recopiée pas dans la mémoire pour devenir la nouvelle valeur de la variable VAR. La valeur de VAR en fin d’exécution des tâches TASK_1 et TASK_2 est la valeur en fin d’exécution de la tâche TASK_1, ce qui traduit bien le fait que la tâche TASK_1 est prioritaire pour la valeur de la variable VAR sur la tâche TASK_2 lorsque la tâche TASK_1 vient temporellement en concurrence de la tâche TASK_2. Pour fins d’illustration, la montre un cas où il n’y a pas de concurrence temporelle entre les tâches TASK_1 et TASK_2, et où la tâche TASK_1 est effectuée temporellement avant TASK_2. Quelles que soient les priorités de TASK_1 et TASK_2 l’une par rapport à l’autre, la valeur de la variable VAR en fin d’exécution des tâches TASK_1 et TASK_2 est la valeur de la variable VAR en fin d’exécution de la tâche TASK_2, car la tâche TASK_2 est initié temporellement après l’exécution de la tâche TASK_1. Lorsque chaque tâche non concurrente TASK_1 ou TASK_2 débute, la valeur de PRIO_DATA en mémoire étant égale à PRIO_INI, chaque tâche est prioritaire dans l’affectation de la variable VAR. Procédé mis en œuvre par ordinateur de gestion de données partagées au travers d’une mémoire, dans lequel une variable VAR partagée est enregistrée dans la mémoire, la variable VAR est accessible par au moins deux tâches TASK_i (i=1…n, n>=2) exécutées en parallèle les unes des autres, chaque tâche TASK_i comprenant au moins un exécutable RUN_ij (j=1…k, k>=1), lorsque la tâche TASK_i comprend au moins deux exécutables RUN_ij ceux-ci sont exécutés séquentiellement, une variable de priorité PRIO_DATA associée à la variable VAR étant stockée dans la mémoire et prenant initialement une valeur PRIO_INI, une constante de priorité PRIO_i étant stockée dans la mémoire pour chacune des tâches TASK_i, la constante de priorité PRIO_i caractérisant l’ordre de priorité de la tâche TASK_i, PRIO_INI étant réservée à la priorité la plus faible et étant différente de chacune des constantes de priorité PRIO_i, chacun des exécutables RUN_ij ayant une constante de priorité PRIO_RUN_ij associée caractérisant l’ordre de priorité de l’exécutable RUN_ij produisant la variable VAR, pour chacune des tâches TASK_i la constante de priorité PRIO_ i de la tâche TASK_i étant le maximum des constantes de priorité PRIO_RUN_ij des exécutables RUN_ij de cette tâche, le procédé comprenant les étapes suivantes: - à un instant t1 : * initier la i-ième tâche TASK_i en utilisant la valeur de la variable VAR partagée à t1 dans la mémoire, et * si PRIO_i> PRIO_DATA à l’instant t1 alors PRIO_DATA est mis à jour à la valeur PRIO_i, - après l’exécution de la même i-ième tâche TASK_i à un instant t2>t1, la i-ième tâche TASK_i génère une valeur VAR_UPDATE_i de la variable VAR, * si PRIO_DATA à l’instant t2 = PRIO_i, alors VAR est mis à jour à la valeur VAR_UPDATE_i et PRIO_DATA est mis à jour à la valeur PRIO_INI. Procédé de gestion de données partagées selon la revendication 1, dans lequel les valeurs de chaque PRIO_i sont strictement croissantes suivant l’ordre de priorité de la tâche TASK_i produisant la variable VAR, PRIO_INI étant plus petite que chacune des constantes de priorité PRIO_i, préférentiellement PRIO_INI=0. Procédé de gestion de données partagées selon la revendication 1 ou 2, dans lequel chacune des tâches TASK_i est exécutée sur un cœur CORE_i qui lui est propre. Procédé de gestion de données partagées selon l’une des revendications précédentes, comprenant de plus un premier tampon BUFF_1 disposé entre la mémoire et un premier cœur CORE_1 sur lequel est exécutée une première tâche TASK_1, et/ou un deuxième tampon BUFF_2 disposé entre la mémoire et un deuxième cœur CORE_2 sur lequel est exécutée une deuxième tâche TASK_2, les premier et deuxième tampons BUFF_1, BUFF_2 comprenant des copies des valeurs des variables VAR utilisées par les tâches TASK_1, TASK2 en entrée et sortie des tâches TASK_1, TASK2, les premier et deuxième tampons BUFF_1, BUFF_2 pouvant interagir avec la mémoire pour modifier la variable VAR en sortie des tâches TASK_i. Procédé de gestion de données partagées selon la revendication 4, dans lequel les premier et deuxième tampons BUFF_1, BUFF_2 comprenant des copies des valeurs des variables VAR en entrée et sortie des exécutables RUN_1j, RUN_2j de chacune des tâches TASK_1, TASK2. Procédé de gestion de données partagées selon l’une des revendications précédentes, dans lequel la création de la constante de priorité PRIO_i est faite hors ligne. Programme informatique, comprenant des instructions pour mettre en œuvre au moins une partie du procédé selon l'une quelconque des revendications précédentes lorsque le logiciel est exécuté par un processeur. Dispositif informatique comprenant : - une mémoire pour stocker au moins des instructions le programme informatique de la revendication précédente, - un processeur accédant à la mémoire pour lire les instructions précitées et exécuter ensuite le procédé selon l'une quelconque des revendications 1 à 6. Support d'enregistrement non transitoire lisible par ordinateur sur lequel un programme informatique est enregistré pour mettre en œuvre le procédé selon l'une quelconque des revendications 1 à 6, lorsque le programme informatique est exécuté par un processeur. Véhicule avec un système embarqué comportant le dispositif informatique de la revendication 8.