EP2867774A1 - Procédé de traitement de données en sécurité, et calculateur associé - Google Patents

Procédé de traitement de données en sécurité, et calculateur associé

Info

Publication number
EP2867774A1
EP2867774A1 EP13732927.2A EP13732927A EP2867774A1 EP 2867774 A1 EP2867774 A1 EP 2867774A1 EP 13732927 A EP13732927 A EP 13732927A EP 2867774 A1 EP2867774 A1 EP 2867774A1
Authority
EP
European Patent Office
Prior art keywords
executable
source code
output data
data
generating
Prior art date
Legal status (The legal status 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 status listed.)
Ceased
Application number
EP13732927.2A
Other languages
German (de)
English (en)
Inventor
Philippe COUPOUX
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
Alstom Transport Technologies SAS
Original Assignee
Alstom Transport SA
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 Alstom Transport SA filed Critical Alstom Transport SA
Publication of EP2867774A1 publication Critical patent/EP2867774A1/fr
Ceased legal-status Critical Current

Links

Classifications

    • G—PHYSICS
    • G06—COMPUTING OR CALCULATING; COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F11/00—Error detection; Error correction; Monitoring
    • G06F11/07—Responding to the occurrence of a fault, e.g. fault tolerance
    • G06F11/14—Error detection or correction of the data by redundancy in operations
    • G06F11/1479—Generic software techniques for error detection or fault masking
    • G06F11/1487—Generic software techniques for error detection or fault masking using N-version programming
    • G—PHYSICS
    • G06—COMPUTING OR CALCULATING; COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F11/00—Error detection; Error correction; Monitoring
    • G06F11/07—Responding to the occurrence of a fault, e.g. fault tolerance
    • G06F11/16—Error detection or correction of the data by redundancy in hardware
    • G06F11/1629—Error detection by comparing the output of redundant processing systems
    • G06F11/1641—Error detection by comparing the output of redundant processing systems where the comparison is not performed by the redundant processing components

Definitions

  • the present invention relates to a method for processing data in security.
  • the present invention also relates to a calculator for the implementation of such a method.
  • Such a device comprises a voting means designed to compare together the data sets generated at the output of each of the processing paths. If the criterion implemented by the means of voting is not respected, the means of voting indicates the presence of a fault in the data generated at the exit.
  • the SIL 4 level corresponds to a probability of occurrence of an unsafe failure of less than 10 "9 .
  • WO 2010/049339 discloses various modes of redundancy in the execution of security software.
  • the same executable is executed on two computation units, independent of one another, which receive the same set of input data.
  • the two calculation units each output the output data following execution of the executable on the input data, and the output data of the two calculation units are compared by a voting means.
  • a second redundancy mode distinct from the first redundancy mode, two different executables are compiled from two separate source codes using the same compiler. The two executables are then executed, either on two different calculation units, or successively on the same calculation unit. The output data corresponding to the processing of the input data by the two executables are then compared by the voting means.
  • a third redundancy mode distinct from the first and second redundancy modes, two different executables are obtained from the same source code using the same compiler and different compilation parameters. Both executables are then executed, either on two different calculation units, or successively on the same calculation unit, and the output data corresponding to the two executables are then compared by the voting means.
  • the object of the invention is to propose a data processing method presenting a better reliability of the data delivered at the end of the treatment.
  • the subject of the invention is a data processing method implemented by a computer comprising a compiler, the method of processing comprising a first step of generating a first executable from a source code corresponding to software, and a second step of generating a second executable from the same source code.
  • the first executable generated is intended to be executed by a first processing unit and the second executable generated is intended to be executed by a second processing unit, distinct from the first processing unit.
  • the source code comprises at least one variable of the integer type and, during the generation step of the second executable, the integer type of the or each variable is converted to a floating type.
  • the method comprises one or more of the following characteristics, taken separately or in any technically possible combination:
  • the step of generating the first executable consists in compiling said source code using the compiler
  • the step of generating the second executable consists in creating an intermediate source code by replacing, in said source code, each declaration of a variable of the integer type by the declaration of a variable of the floating type, and then compiling said source code intermediate using the compiler implemented during the generation step of the first executable;
  • the step of generating the second executable consists in compiling said source code by associating, with the or each variable of the integer type, a file of a library corresponding to a floating type;
  • the method further comprises a step of execution by the calculation unit of the first executable for processing an input data set in order to generate a first an output data set, an execution step by the calculating unit of the second executable for processing said set of input data to generate a second set of output data, and a voting step by a unit of voting consisting in generating a vote signal based on the result of a comparison between the first and second sets of output data;
  • the step of generating the vote signal comprises converting the first set of output data, the integer type data being converted to floating type output data, and comparing each converted output data with a corresponding data item of the output type; second set of output data;
  • the step of generating a vote signal comprises converting the second set of output data, the floating type data being converted into output data of the integer type, and comparing each converted output data with a data item; corresponding of the first set of output data;
  • the floating type is a double precision floating point in accordance with the IEEE-754 standard;
  • each variable of the source code is of the integer type;
  • said first processing unit is an arithmetic unit for integers dedicated to operations on variables of the integer type and said second processing unit is an arithmetic unit for the floats dedicated to operations on variables of the floating type, and the step d execution of the first executable is performed by the arithmetic unit for the integers and the execution step of the second executable is performed by the arithmetic unit for the floats;
  • an output data output step corresponding to the first set of output data, and the output data (Dout) has a security level in accordance with the SIL4 level of the generalist IEC61508 standard and the lower levels (SIL3 to SIL3) of it complies with the levels: SILO to SIL4 of the sectoral standard EN50129 or complies with Class2 to Classl levels of the industry standard IEC61513.
  • the invention also relates to a computer comprising a compiler, the compiler comprising a module for generating a first executable from a source code corresponding to a software, and means for generating a second executable from the same source code.
  • the first executable generated is intended to be executed by a first processing unit and the second executable generated is intended to be executed by a second processing unit, distinct from the first processing unit.
  • the source code comprises at least one variable of the integer type, and in that the generation means are adapted to convert the integer type of the or each variable to a floating type when the second executable is generated.
  • the calculator further comprises a calculation unit comprising said first and second processing units and a voting unit, the calculation unit being capable of executing, on the one hand, the first executable for the processing a set of input data to generate a first set of output data, and secondly, the second executable for processing said set input data to generate a second set of output data, and the polling unit being adapted to generate a vote signal based on the result of a comparison between the first and second sets of output data.
  • FIG. 1 is a schematic representation of a computer for implementing a secure data processing method
  • FIG. 2 is a flowchart showing the steps of the secure data processing method.
  • integer type signed or unsigned (“Integer” or “Unsigned Integer” in English) called “int” or “unsigned int” in C language or similar names in other languages, used for integer or Boolean variables and coded in memory on 2 or 4 bytes, that is to say 16 or 32 bits.
  • integer type groups together the set of variable types that can usually declare integers and manipulate them by means of arithmetic or logical operations on integers.
  • FLOAT single-precision floating type
  • Double-precision floating type DOUBLE
  • 8 bytes ie 64 bits: 52 bits of mantissa, 1 1 bits of exponent and 1 bit of sign
  • the floating type double precision extended LONG DOUBLE
  • 10 bytes ie 80 bits: 64 bits of mantissa, 15 bits of exponent and 1 bit of sign
  • the processes correspond to either logical operations, such as AND, OR, etc., performed on Boolean data, 0 or 1, either to arithmetic operations, such as MORE, LESS, DIVIDE, MULTIPLY, performed on integer data, 0, 1, 2, 3, etc.
  • the security software is intended to be executed on a computer 10.
  • the computer 10 comprises an input interface 12, a calculation unit 14, a voting unit 16 and an output interface 18.
  • the compiler is implemented in the computer 10.
  • the calculator comprising the calculation unit is separated from a calculator comprising the voting unit.
  • the computer 10 comprises a bus 20 for data flow between the input interface 12 and the output interface 18, the calculation unit 14, the voting unit 16 being able to exchange data with the bus 20
  • the compiler 19 is at the bus 20 for exchanging data with the bus 20.
  • the input interface 12 is adapted to receive Din input data and to transmit them to the calculation unit 14 via the bus 20.
  • the computing unit 14 comprises a microprocessor 22 and a memory 24.
  • the microprocessor 22 comprises several arithmetic units and, in particular, an arithmetic unit for the integers 30 and an arithmetic unit for the floats 32.
  • the arithmetic unit for integers 30 (also called “Arithmetic Logic Unit” in English) is dedicated to operations on variables of the integer type.
  • the arithmetic unit for floats 32 (also called “Floating Point Unit” in English) is dedicated to operations on single-precision floating type variables.
  • the floating type corresponds to the double precision floating type, respectively to the double precision extended floating type
  • the microprocessor comprises an arithmetic unit for the double precision floats, respectively for the extended double precision floats, not shown, which is dedicated to the operations on variables of the floating type double precision, respectively the double precision extended floats.
  • the memory 24 is able to store the instructions of a first executable L1 and a second executable L2 which will be presented hereinafter, the microprocessor 22 being able to execute the first executable L1 and the second executable L2, on the same data. Din.
  • the microprocessor 22 is capable of sequentially executing the first executable L1, then the second executable L2, sequentially executing the second executable L2 and then the first executable L1 and / or executing the first executable L2. executable L1 and the second executable L2 in parallel, according to a scheduling scheme.
  • the memory 24 also comprises a first memory zone 40 for storing the values of the variables declared during the execution of the first executable L1.
  • this first memory zone 40 makes it possible to store all the output data Dout1 resulting from the processing of the input data Din during execution by the microprocessor 22 of the first executable L1.
  • the memory 24 includes a second memory zone 42 for storing the values of the variables declared during the execution of the second executable L2.
  • this second memory zone 42 makes it possible to store all of the output data Dout2 resulting from the processing of the input data Din during execution by the microprocessor 22 of the second executable L2.
  • the voting unit 16 is able to process the output data Dout1 (respectively Dout2) or a representative transformation of the output data Dout1 (respectively Dout2). Subsequently, the output data Dout1 (respectively Dout2) represents the set of output data or a representative transformation of the output data.
  • the polling unit 16 comprises a reading and conversion means 50 able to read the first set of output data Dout1 in the first memory area 40 and to convert these data Dout1 from the integer type to the single precision floating type to obtain data. converted data Dout1 _conv, and reading the second set of output data Dout2 in the second memory area 42.
  • the voting unit 16 comprises a comparison means 52 designed to compare the first and second sets of output data Dout1 _conv, Dout2 read and possibly converted by the reading and conversion means 50.
  • the comparison means 52 is suitable for implementing a comparison criterion consisting, for example, in determining a difference between a data item Dout1 conv of the first set whose type has been converted and a corresponding datum Dout2 of the second set. This difference corresponds to a bitwise comparison of these two data Dout1 _conv, Dout2 the difference taking the Boolean value 1 as soon as two bits are different or the Boolean value 0 if all the bits are identical.
  • the difference does not necessarily take the values 1/0. As a variant, the difference takes the corresponding values false / true or difference / no difference.
  • the criterion implemented by the voting unit 16 is checked when all the deviations thus calculated for the set of data Dout1_conv, Dout2 are all equal to zero or, in other words, that no difference has the value 1.
  • the reading and converting means 50 is adapted to read the second set of output data Dout2 in the second memory area 42 and to convert these floating-point data Dout2 to the integer type to obtain converted data Dout2_conv, and reading the first set of output data Doutl in the first memory area 40.
  • the comparison means 52 is able to compare the first and second sets of output data Dout1, Dout2_conv read together and possibly converted by the reading and converting means 50 to one another.
  • the comparison means 52 is then able to implement a comparison criterion consisting, for example, in determining a difference between a data item Doutl of the first set and a data item Dout2_conv. This difference corresponds to a bitwise comparison of these two data Dout1, Dout2_conv, the difference taking the Boolean value 1 as soon as two bits are different.
  • the criterion implemented by the voting unit 16 is checked when all the deviations thus calculated for the set of data Doutl, Dout2_conv are all equal to zero or, in other words, that no difference has the value 1.
  • the comparison means 52 is also able to transmit to the output interface 18 the first set of output data Doutl as a safe output data Dout, and a binary voting signal S.
  • the vote signal S takes the Boolean value 0 if the first and second sets of output data Dout1, Dout2 respect the comparison criterion implemented by the voting unit 16. Otherwise, the vote signal S takes the Boolean value. 1.
  • the output interface 18 comprises, for example, a display means for displaying the output data safely Dout, as well as the vote signal S.
  • the vote signal S is, for example, displayed in the form a green flag when the value of this signal is Boolean 0, or in the form of a red flag when the value of this signal is Boolean 1.
  • the compiler 19 comprises a module 60 for analyzing the syntax of the source code L0 and for converting the integer type of each corresponding variable into a floating type, and a module 62 for compiling a given source code into an executable according to parameters of predefined compilation.
  • the analysis and conversion module 60 is able to generate an intermediate source code L0 'from the source code L0, by converting, after parsing, the integer type of each corresponding variable into a floating type.
  • the compilation module 62 is known per se, and is clean in the embodiment described to compile, on the one hand, the source code L0 into the first executable L1, and on the other hand, the intermediate source code L0 'into the second executable L2.
  • the analysis and conversion module 60 and the compilation module 62 then form means for generating the second executable L2 from the same source code LO.
  • the compiler 19 includes the compilation module 62 and a compilation library, not shown. According to this variant, the compiler 19 does not include a module for analyzing the syntax of the source code LO and converting the integer type of each corresponding variable into a floating type.
  • the compilation module 62 is able to compile said source code LO by associating, with the or each variable of the integer type, a file of the compilation library corresponding to a floating type, in order to generate the second executable L2.
  • a programmer wanting to perform security software writes the source code LO.
  • the different variables used in this LO source code are of the integer type.
  • step 1 10 the first executable L1 is generated by compiling the source code
  • the first executable L1 is then stored in the memory 24 of the computing unit 14.
  • the variables of the first executable L1 are of the integer type, given that the variables of the source code LO are of the integer type.
  • step 120 of generation of the intermediate source code LO ' the analysis and conversion module 60 analyzes the syntax of the source code LO and converts the integer type of each variable into a IEEE-754 simple-precision floating-point type. generating the intermediate source code LO '.
  • the set of integers initially coded on 8 and 16 bits can be converted, exactly, on the mantissa part of the single precision floats.
  • the analysis and conversion module 60 analyzes the syntax of the source code L0 and converts the integer type of each variable into an IEEE-754 double precision floating type so as to generate the intermediate source code L0 '.
  • the set of integers initially coded on 8, 16 and 32 bits can be converted exactly on the mantissa part of the double precision floats.
  • the variables of the intermediate source code L0 ' are all of the floating type, double precision or simple precision, since the variables of the source code L0 are all of the integer type.
  • the second executable L2 is generated by compiling the intermediate source code LO 'using the compiler.
  • the second executable L2 is stored in the memory 24 of the computing unit 14.
  • the same compiler is preferably used to generate the first executable L1 and the second executable L2.
  • the variables of the second executable L2 are all of the floating type, double precision or simple precision, since the variables of the intermediate source LO 'are all of the floating type, double precision or simple precision.
  • step 140 the first executable L1 is first executed by the microprocessor 22 to process the input data set Din and generate the first set of output data Douti. These Douti output data are stored in the first memory area 40.
  • the microprocessor 22 since the variables of the first executable L1 are all of the integer type, the microprocessor 22 only uses the arithmetic unit for the integers 30.
  • step 150 the second executable L2 is executed by the microprocessor 22 to process the input data set Din and generate the second set of output data Dout2. These output data Dout2 are stored in the second memory zone 42.
  • the microprocessor 22 only uses the arithmetic unit for the floats 32.
  • Steps 140 and 150 are performed sequentially (step 140 then step
  • step 160 the voting unit 16 reads the first and second sets of output data, Douti and Dout2, and converts data from the first set Douti of the integer type to the floating type to obtain the converted data Douti conv.
  • the polling unit 16 reads the first and second sets of output data, Douti and Dout2, and converts data from the second set Dout2 of the floating type to the integer type to obtain the converted data Dout2_conv.
  • step 170 the voting unit 16 compares each converted data of the first set Douti conv with the corresponding data of the second set of data Dout2. This comparison consists in comparing, for example bit by bit, these two data. If they are identical, the difference between these data takes the null value Boolean, to default it takes the Boolean value unit. The comparison criterion is not checked as soon as a difference between two data takes the unit value.
  • the voting unit 16 compares each converted data of the second set Dout2_conv with the corresponding data of the first set of data Doutl.
  • the vote signal S takes the value zero. In the opposite case, the vote signal S takes the value unit.
  • step 180 the voting unit 16 transmits to the output interface 18 the first set of output data Doutl as safe output data Dout, as well as the vote signal S generated during the step 170.
  • step 190 the output interface 18 displays the output data safely Dout that have been transmitted to it, as well as the vote signal S.
  • the vote signal S is for example included in the data (for example value explicit, data encoding) or separated from the data.
  • the conversion from the integer type to the floating type is performed at the level of the source code language via the generation of the intermediate source code L0 ', which code is then compiled.
  • the output data Dout has a level of security compliant with the SIL4 level of the generalist IEC61508 standard and at the lower levels (SIL3 to SIL3) thereof or compliant with the levels: SILO to SIL4 of the sectoral standard EN50129 or compliant at the Class2 to Classl levels of the industry standard IEC61513.
  • this conversion from the integer type to the floating type is done directly during the compilation of the source code L0.
  • the compiler then comprises, for example, a compilation option for activating a module of the own link editor, whenever an integer variable is declared in the source code L0, to use a file of the library that is the floating type, instead of using the library file that corresponds to the integer type.
  • the present invention applies to any software, but is particularly well suited to the case of a security software working on integer variables.
  • the microprocessor uses only its arithmetic unit for integers.
  • the microprocessor will only use its arithmetic unit for the floats during the implementation of the redundancy of the processing.
  • the processing method according to the invention allows the redundancy of the data processing by a diversification of the processing means, and improves thus the reliability of the data delivered at the end of the treatment.
  • the inventors have surprisingly found that the IEEE-754 double precision floating type was particularly suitable as a particular type of float for the implementation of the method according to the invention, whereas this type of float is not usually used to make Boolean logic or whole arithmetic.
  • the part of mantissa double precision floats allows to accurately represent the integers coded on 32 bits. 32-bit integers therefore always have an exact representation in the IEEE-754 double precision floating type, since the number of bits that compose them, namely 32, is strictly less than 52 bits, which is the number of bits composing the mantissa. IEE-754 double precision floats.
  • the IEEE-754 single-precision float type with its 23 mantissa bits makes it possible to accurately represent integers coded on 8 or 16 bits.

Landscapes

  • Engineering & Computer Science (AREA)
  • Theoretical Computer Science (AREA)
  • Quality & Reliability (AREA)
  • Physics & Mathematics (AREA)
  • General Engineering & Computer Science (AREA)
  • General Physics & Mathematics (AREA)
  • Devices For Executing Special Programs (AREA)

Abstract

Ce procédé, mis en oeuvre par un calculateur comportant un compilateur, comprend une première étape (110) de génération d'un premier exécutable (L1) à partir d'un code source (L0) correspondant à un logiciel, et une deuxième étape (120; 130) de génération d'un second exécutable (L2) à partir du même code source (L0). Le premier exécutable généré (L1) est destiné à être exécuté par une première unité de traitement (30) et le deuxième exécutable généré (L2) est destiné à être exécuté par une deuxième unité de traitement (32), distincte de la première unité de traitement (30). Le code source (L0) comporte au moins une variable du type entier et, lors de l'étape (120; 130) de génération du second exécutable (L2), le type entier de la ou chaque variable est converti en type flottant.

Description

Procédé de traitement de données en sécurité, et calculateur associé
La présente invention concerne un procédé de traitement de données en sécurité. La présente invention concerne également un calculateur pour la mise en œuvre d'un tel procédé.
L'exécution d'un logiciel de traitement de données et, en particulier, celle d'un logiciel de sécurité doit se faire en sécurité, c'est-à-dire de manière à pouvoir garantir, avec une faible probabilité d'erreur résiduelle (1 .10~9) la fiabilité d'une donnée générée en sortie.
Pour ce faire, on connaît des dispositifs permettant une redondance de l'exécution du logiciel de sécurité, en diversifiant les chemins de traitement d'un ensemble de données d'entrée. Un tel dispositif comporte un moyen de vote conçu pour comparer entre eux les ensembles de données générées en sortie de chacun des chemins de traitement. Si le critère mis en œuvre par le moyen de vote n'est pas respecté, le moyen de vote indique la présence d'une faute dans les données générées en sortie.
II est ainsi possible d'éliminer, de tolérer, ou d'identifier les fautes susceptibles d'affecter le traitement des données effectué par le logiciel de sécurité.
La probabilité de l'occurrence de fautes qui ne seraient pas identifiées comme telles, permet de qualifier le niveau de sécurité atteint. Ainsi, selon la norme généraliste IEC61508, le niveau SIL 4 correspond à une probabilité d'occurrence d'une défaillance contraire à la sécurité inférieure à 10"9.
Le document WO 2010/049339 divulgue différents modes de redondance dans l'exécution d'un logiciel de sécurité.
Selon un premier mode de redondance, le même exécutable est exécuté sur deux unités de calcul, indépendantes l'une de l'autre, qui reçoivent le même ensemble de données d'entrée. Les deux unités de calcul délivrent chacune des données de sortie suite à l'exécution de l'exécutable sur les données d'entrée, et les données de sortie des deux unités de calcul sont comparées par un moyen de vote.
Selon un deuxième mode de redondance, distinct du premier mode de redondance, deux exécutables différents sont compilés à partir de deux codes source distincts en utilisant le même compilateur. Les deux exécutables sont ensuite exécutés, soit sur deux unités de calcul différentes, soit successivement sur une même unité de calcul. Les données de sortie correspondant au traitement des données d'entrée par les deux exécutables sont ensuite comparées par le moyen de vote.
Selon un troisième mode de redondance, distinct des premier et deuxième modes de redondance, deux exécutables différents sont obtenus à partir d'un même code source en utilisant le même compilateur et des paramètres de compilation différents. Les deux exécutables sont ensuite exécutés, soit sur deux unités de calcul différentes, soit successivement sur une même unité de calcul, et les données de sortie correspondant aux deux exécutables sont ensuite comparées par le moyen de vote.
L'invention a pour but de proposer un procédé de traitement de données présentant une meilleure fiabilité des données délivrées à l'issue du traitement.
Pour cela, l'invention a pour objet un procédé de traitement de données, mis en œuvre par un calculateur comportant un compilateur, le procédé de traitement comprenant une première étape de génération d'un premier exécutable à partir d'un code source correspondant à un logiciel, et une deuxième étape de génération d'un second exécutable à partir du même code source. Le premier exécutable généré est destiné à être exécuté par une première unité de traitement et le deuxième exécutable généré est destiné à être exécuté par une deuxième unité de traitement, distincte de la première unité de traitement. Le code source comporte au moins une variable du type entier et, lors de l'étape de génération du second exécutable, le type entier de la ou chaque variable est converti en type flottant.
Suivant des modes particuliers de réalisation, le procédé comporte une ou plusieurs des caractéristiques suivantes, prise(s) isolément ou suivant toutes les combinaisons techniquement possibles :
- l'étape de génération du premier exécutable consiste à compiler ledit code source à l'aide du compilateur ;
- l'étape de génération du second exécutable consiste à créer un code source intermédiaire en remplaçant, dans ledit code source, chaque déclaration d'une variable du type entier par la déclaration d'une variable du type flottant, puis à compiler ledit code source intermédiaire en utilisant le compilateur mis en œuvre lors de l'étape de génération du premier exécutable ;
- l'étape de génération du second exécutable consiste à compiler ledit code source en associant, à la ou chaque variable du type entier, un fichier d'une librairie correspondant à un type flottant ;
- une unité de calcul comportant lesdites première et seconde unités de traitement, le procédé comprend en outre une étape d'exécution par l'unité de calcul du premier exécutable pour le traitement d'un ensemble de données d'entrée afin de générer un premier ensemble de données de sortie, une étape d'exécution par l'unité de calcul du second exécutable pour le traitement dudit ensemble de données d'entrée afin de générer un second ensemble de données de sortie, et une étape de vote par une unité de vote consistant à générer un signal de vote en fonction du résultat d'une comparaison entre les premier et second ensembles de données de sortie ; - l'étape de génération du signal de vote comprend la conversion du premier ensemble de données de sortie, les données du type entier étant converties en données de sortie du type flottant, et la comparaison de chaque donnée de sortie convertie avec une donnée correspondante du second ensemble de données de sortie ;
- l'étape de génération d'un signal de vote comprend la conversion du second ensemble de données de sortie, les données du type flottant étant converties en données de sortie du type entier, et la comparaison de chaque donnée de sortie convertie avec une donnée correspondante du premier ensemble de données de sortie ;
- le type flottant est un flottant double précision conforme à la norme IEEE-754 ; - chaque variable du code source est du type entier ;
- ladite première unité de traitement est une unité arithmétique pour les entiers dédiée aux opérations sur des variables du type entier et ladite seconde unité de traitement est une unité arithmétique pour les flottants dédiée aux opérations sur des variables du type flottant, et l'étape d'exécution du premier exécutable est effectuée par l'unité arithmétique pour les entiers et la étape d'exécution du second exécutable est effectuée par l'unité arithmétique pour les flottants ;
- une étape de délivrance de données de sortie correspondant au premier ensemble de données de sortie, et les données de sortie (Dout) présentent un niveau de sécurité conforme au niveau SIL4 de la norme généraliste IEC61508 et au niveaux inférieurs (SILO à SIL3) de celui-ci ou conforme aux niveaux: SILO à SIL4 de la norme sectorielle EN50129 ou conforme aux niveaux Class2 à Classl de la norme sectorielle IEC61513.
L'invention a également pour objet un calculateur comprenant un compilateur, le compilateur comportant un module de génération d'un premier exécutable à partir d'un code source correspondant à un logiciel, et des moyens de génération d'un second exécutable à partir du même code source. Le premier exécutable généré est destiné à être exécuté par une première unité de traitement et le deuxième exécutable généré est destiné à être exécuté par une deuxième unité de traitement, distincte de la première unité de traitement. Le code source comporte au moins une variable du type entier, et en ce que les moyens de génération sont propres à convertir le type entier de la ou chaque variable en type flottant lors de la génération du second exécutable.
Suivant un mode particulier de réalisation, le calculateur comprend en outre une unité de calcul comportant lesdites première et seconde unités de traitement et une unité de vote, l'unité de calcul étant propre à exécuter, d'une part, le premier exécutable pour le traitement d'un ensemble de données d'entrée afin de générer un premier ensemble de données de sortie, et d'autre part, le second exécutable pour le traitement dudit ensemble de données d'entrée afin de générer un second ensemble de données de sortie, et l'unité de vote étant propre à générer un signal de vote en fonction du résultat d'une comparaison entre les premier et second ensembles de données de sortie.
L'invention et ses avantages seront mieux compris à la lecture de la description qui va suivre, donnée uniquement à titre d'exemple non limitatif, et faite en se référant aux dessins annexés sur lesquels :
- la Figure 1 est une représentation schématique d'un calculateur pour la mise en œuvre d'un procédé de traitement de données en sécurité ; et
- la Figure 2 est un organigramme représentant les étapes du procédé de traitement de données en sécurité.
Pour le développement d'un logiciel de sécurité, lors de l'écriture d'un code source L0 correspondant à ce logiciel de sécurité, le programmeur déclare chaque nouvelle variable en associant un type de variable à un nom.
Parmi les différents types de variable classiquement à la disposition des programmeurs pour déclarer des entiers, il existe le type entier, signé ou non-signé (« Integer » ou « Unsigned Integer » en anglais) dénommé « int » ou « unsigned int » en langage C ou de nom similaires dans d'autres langages, utilisé pour des variables entières ou booléennes et codé en mémoire sur 2 ou 4 octets, c'est-à-dire 16 ou 32 bits.
Il existe également le type chaîne de caractères (« unsigned character » en anglais) dénommé « unsigned char » en langage C, permettant de coder des entiers non signés prenant les valeurs 0 a 255 sur un octet, c'est-à-dire sur 8 bits. Ce type est parfois utilisé pour implémenter les variables booléennes.
Dans ce qui suit, le terme « type entier » regroupe l'ensemble des types de variable permettant usuellement de déclarer des entiers et de les manipuler au moyen d'opérations arithmétiques ou logiques sur les entiers.
Parmi les différents types de variable classiquement à la disposition des programmeurs pour déclarer des réelles avec une virgule flottante, il existe le type flottant (« Float » en anglais »), dénommé FLOAT, DOUBLE ou LONG DOUBLE en langage C, utilisé pour des variables réelles. Ainsi, selon la norme IEEE-754, le type flottant simple précision (FLOAT) permet de coder un réel en mémoire sur 4 octets (soit 32 bits : 23 bits de mantisse, 8 bits d'exposant et 1 bit de signe), le type flottant double précision (DOUBLE), sur 8 octets (soit 64 bits : 52 bits de mantisse, 1 1 bits d'exposant et 1 bit de signe), et le type flottant double précision étendue (LONG DOUBLE), sur 10 octets (soit 80 bits : 64 bits de mantisse, 15 bits d'exposant et 1 bit de signe).
Pour un logiciel de sécurité, utilisant des variables de type entier, les traitements correspondent soit à des opérations logiques, telles que ET, OU, etc., effectuées sur des données booléennes, 0 ou 1 , soit à des opérations arithmétiques, tels que PLUS, MOINS, DIVISER, MULTIPLIER, effectuées sur des données entières, 0, 1 , 2, 3, etc.
Le logiciel de sécurité est destiné à être exécuté sur un calculateur 10.
En se référant à la figure 1 , le calculateur 10 comporte une interface d'entrée 12, une unité de calcul 14, une unité de vote 16 et une interface de sortie 18.
Dans le mode de réalisation décrit ici en détail, le calculateur 10 et le compilateur 19 sont séparés
En variante d'autres architectures sont envisageables. Par exemple, le compilateur est implanté dans le calculateur 10. Dans un autre exemple, le calculateur comportant l'unité de calcul est séparé d'un calculateur comportant l'unité de vote.
Le calculateur 10 comporte un bus 20 de circulation des données entre l'interface d'entrée 12 et l'interface de sortie 18, l'unité de calcul 14, l'unité de vote 16 étant aptes à échanger des données avec le bus 20. Le compilateur 19 est au bus 20 pour échanger des données avec le bus 20.
L'interface d'entrée 12 est propre à recevoir des données d'entrée Din et à les transmettre à l'unité de calcul 14 via le bus 20.
L'unité de calcul 14 comporte un microprocesseur 22 et une mémoire 24.
Le microprocesseur 22 comporte plusieurs unités arithmétiques et, en particulier, une unité arithmétique pour les entiers 30 et une unité arithmétique pour les flottants 32.
L'unité arithmétique pour les entiers 30 (aussi dénommée « Arithmetic Logic Unit » en anglais) est dédiée aux opérations sur des variables du type entier.
L'unité arithmétique pour les flottants 32 (aussi dénommée « Floating Point Unit » en anglais ») est dédiée aux opérations sur des variables du type flottant simple précision.
En variante, le type flottant correspond au type flottant double précision, respectivement au type flottant double précision étendue, et le microprocesseur comporte une unité arithmétique pour les flottants double précision, respectivement pour les flottants double précision étendue, non représentée, qui est dédiée aux opérations sur des variables du type flottant double précision, respectivement les flottants double précision étendue.
La mémoire 24 est apte à stocker les instructions d'un premier exécutable L1 et d'un second exécutable L2 qui seront présentés ci-après, le microprocesseur 22 étant propre à exécuter le premier exécutable L1 et le second exécutable L2, sur les mêmes données d'entrée Din. Le microprocesseur 22 est propre à exécuter séquentiellement le premier exécutable L1 , puis le second exécutable L2, à exécuter séquentiellement le second exécutable L2 puis le premier exécutable L1 et/ou à exécuter le premier exécutable L1 et le deuxième exécutable L2 en parallèle, selon un plan d'ordonnancement.
La mémoire 24 comporte également une première zone mémoire 40 pour le stockage des valeurs des variables déclarées lors de l'exécution du premier exécutable L1 . En particulier, cette première zone mémoire 40 permet de stocker l'ensemble des données de sortie Doutl résultant du traitement des données d'entrée Din lors de l'exécution par le microprocesseur 22 du première exécutable L1 .
La mémoire 24 comporte une seconde zone mémoire 42 pour le stockage des valeurs des variables déclarées lors de l'exécution du second exécutable L2. En particulier, cette seconde zone mémoire 42 permet de stocker l'ensemble des données de sortie Dout2 résultant du traitement des données d'entrée Din lors de l'exécution par le microprocesseur 22 du second exécutable L2.
L'unité de vote 16 est propre à traiter les données de sortie Doutl (respectivement Dout2) ou une transformation représentative des données de sortie Doutl (respectivement Dout2). Par la suite, les données de sortie Doutl (respectivement Dout2) représentent l'ensemble des données de sortie ou une transformation représentative des données de sortie.
L'unité de vote 16 comporte un moyen de lecture et de conversion 50 propre à lire le premier ensemble de données de sortie Doutl dans la première zone mémoire 40 et à convertir ces données Doutl du type entier vers le type flottant simple précision pour obtenir des données converties Doutl _conv, et à lire le second ensemble de données de sortie Dout2 dans la seconde zone mémoire 42.
L'unité de vote 16 comporte un moyen de comparaison 52 conçu pour comparer entre eux les premier et second ensembles de données de sortie Doutl _conv, Dout2 lues et éventuellement converties par le moyen de lecture et de conversion 50.
Le moyen de comparaison 52 est propre à mettre en œuvre un critère de comparaison consistant, par exemple, à déterminer un écart entre une donnée Doutl conv du premier ensemble dont le type a été converti et une donnée Dout2 correspondante du second ensemble. Cet écart correspond à une comparaison bit à bit de ces deux données Doutl _conv, Dout2 l'écart prenant la valeur booléenne 1 dès que deux bits sont différents ou la valeur booléenne 0 si tous les bits sont identiques.
A noter que l'écart ne prend pas nécessairement les valeurs 1 /0. En variante, l'écart prend les valeurs correspondantes faux/vrai ou écart/pas d'écart.
Le critère mis en œuvre par l'unité de vote 16 est vérifié lorsque tous les écarts ainsi calculés pour l'ensemble des données Dout1_conv, Dout2 sont tous égaux à zéro ou, dit autrement, qu'aucun écart ne présente la valeur 1 . En variante, le moyen de lecture et de conversion 50 est propre à lire le second ensemble de données de sortie Dout2 dans la seconde zone mémoire 42 et à convertir ces données Dout2 du type flottant vers le type entier pour obtenir des données converties Dout2_conv, et à lire le premier ensemble de données de sortie Doutl dans la première zone mémoire 40.
Selon cette variante, le moyen de comparaison 52 est propre à comparer entre eux les premier et second ensembles de données de sortie Doutl , Dout2_conv lues et éventuellement converties par le moyen de lecture et de conversion 50
Le moyen de comparaison 52 est alors propre à mettre en œuvre un critère de comparaison consistant, par exemple, à déterminer un écart entre une donnée Doutl du premier ensemble et une donnée Dout2_conv. Cet écart correspond à une comparaison bit à bit de ces deux données Doutl , Dout2_conv, l'écart prenant la valeur booléenne 1 dès que deux bits sont différents. Le critère mis en œuvre par l'unité de vote 16 est vérifié lorsque tous les écarts ainsi calculés pour l'ensemble des données Doutl , Dout2_conv sont tous égaux à zéro ou, dit autrement, qu'aucun écart ne présente la valeur 1 .
Le moyen de comparaison 52 est également propre à transmettre à l'interface de sortie 18 le premier ensemble de données de sortie Doutl en tant que donnée de sortie en sécurité Dout, ainsi qu'un signal de vote S binaire.
Le signal de vote S prend la valeur booléenne 0 si les premier et second ensembles de données de sortie Doutl , Dout2 respectent le critère de comparaison mis en œuvre par l'unité de vote 16. Sinon, le signal de vote S prend la valeur booléenne 1 .
L'interface de sortie 18 comporte, par exemple, un moyen d'affichage permettant d'afficher les données de sortie en sécurité Dout, ainsi que le signal de vote S. Le signal de vote S est, par exemple, affiché sous la forme d'un drapeau vert lorsque la valeur de ce signal est la valeur booléenne 0, ou bien sous la forme d'un drapeau rouge lorsque la valeur de ce signal est la valeur booléenne 1 .
Le compilateur 19 comporte un module 60 d'analyse de la syntaxe du code source L0 et de conversion du type entier de chaque variable correspondante en type flottant, et un module 62 de compilation d'un code source donné en un exécutable selon des paramètres de compilation prédéfinis.
Le module d'analyse et de conversion 60 est propre à générer un code source intermédiaire L0' à partir du code source L0, en convertissant, après analyse syntaxique, le type entier de chaque variable correspondante en type flottant.
Le module de compilation 62 est connu en soi, et est propre dans le mode de réalisation décrit à compiler, d'une part, le code source L0 en le premier exécutable L1 , et d'autre part, le code source intermédiaire L0' en le second exécutable L2. Le module d'analyse et de conversion 60 et le module de compilation 62 forment alors des moyens de génération du second exécutable L2 à partir du même code source LO.
En variante, le compilateur 19 comporte le module de compilation 62 et une librairie de compilation, non représentée. Selon cette variante, le compilateur 19 ne comporte pas de module d'analyse de la syntaxe du code source LO et de conversion du type entier de chaque variable correspondante en type flottant. Le module de compilation 62 est propre à compiler ledit code source LO en associant, à la ou chaque variable du type entier, un fichier de la librairie de compilation correspondant à un type flottant, afin de générer le second exécutable L2.
Le procédé de traitement de données en sécurité va maintenant être décrit en référence à la figure 2.
A l'étape 100, un programmeur voulant réaliser un logiciel de sécurité écrit le code source LO. Les différentes variables utilisées dans ce code source LO sont du type entier.
A l'étape 1 10, le premier exécutable L1 est généré par compilation du code source
LO à l'aide du module de compilation 62. Le premier exécutable L1 est ensuite stocké dans la mémoire 24 de l'unité de calcul 14. Dans le mode de réalisation décrit, les variables du premier exécutable L1 sont du type entier, étant donné que les variables du code source LO sont du type entier.
Par compilation, on entend l'utilisation d'un compilateur adapté, intégrant éventuellement un éditeur de lien pour l'intégration de codes binaires élémentaires provenant d'une librairie adaptée.
A l'étape 120 de génération du code source intermédiaire LO', le module d'analyse et de conversion 60 analyse la syntaxe du code source LO et convertit le type entier de chaque variable, en type flottant simple précision IEEE-754, de manière à générer le code source intermédiaire LO'. Selon ce mode de réalisation, l'ensemble des entiers initialement codés sur 8 et 16 bits peut être converti, de manière exacte, sur la partie de mantisse des flottants simple précision.
En variante, le module d'analyse et de conversion 60 analyse la syntaxe du code source L0 et convertit le type entier de chaque variable, en type flottant double précision IEEE-754, de manière à générer le code source intermédiaire L0'. Selon cette variante de réalisation, l'ensemble des entiers initialement codés sur 8, 16 et 32 bits peut être converti de manière exacte sur la partie de mantisse des flottants double précision.
Dans le mode de réalisation décrit, les variables du code source intermédiaire L0' sont toutes du type flottant, double précision ou bien simple précision, étant donné que les variables du code source L0 sont toutes du type entier. A l'étape 130, le second exécutable L2 est généré par compilation du code source intermédiaire LO' à l'aide du compilateur. Le second exécutable L2 est stocké dans la mémoire 24 de l'unité de calcul 14. Le même compilateur est de préférence utilisé pour générer le premier exécutable L1 et le second exécutable L2. Dans le mode de réalisation décrit, les variables du second exécutable L2 sont toutes du type flottant, double précision ou bien simple précision, étant donné que les variables du source intermédiaire LO' sont toutes du type flottant, double précision ou bien simple précision.
Puis, périodiquement, pour chaque nouvel ensemble de données d'entrée Din transmis par l'interface d'entrée 12 à l'unité de calcul 14, le procédé se poursuit de la manière suivante.
A l'étape 140, le premier exécutable L1 est d'abord exécuté par le microprocesseur 22 pour traiter l'ensemble de données d'entrée Din et générer le premier ensemble de données de sortie Douti . Ces données de sortie Douti sont stockées dans la première zone mémoire 40.
Au cours de cette étape, puisque les variables du premier exécutable L1 sont toutes du type entier, le microprocesseur 22 fait uniquement appel à l'unité arithmétique pour les entiers 30.
A l'étape 150, le second exécutable L2 est exécuté par le microprocesseur 22 pour traiter l'ensemble de données d'entrée Din et générer le second ensemble de données de sortie Dout2. Ces données de sortie Dout2 sont stockées dans la seconde zone mémoire 42.
Au cours de cette étape, puisque les variables du second exécutable L2 sont toutes du type flottant, double précision ou bien simple précision, le microprocesseur 22 fait uniquement appel à l'unité arithmétique pour les flottants 32.
Les étapes 140 et 150 sont effectuées séquentiellement (étape 140 puis étape
150 ou inversement) ou en parallèle.
A l'étape 160, l'unité de vote 16 lit les premier et second ensembles de données de sortie, Douti et Dout2, et convertit des données du premier ensemble Douti du type entier vers le type flottant pour obtenir les données converties Douti conv.
En variante, l'unité de vote 16 lit les premier et second ensembles de données de sortie, Douti et Dout2, et convertit des données du second ensemble Dout2 du type flottant vers le type entier pour obtenir les données converties Dout2_conv.
A l'étape 170, l'unité de vote 16 compare chaque donnée convertie du premier ensemble Douti conv avec la donnée correspondante du second ensemble de données Dout2. Cette comparaison consiste à comparer, par exemple bit à bit, ces deux données. Si elles sont identiques, l'écart entre ces données prend la valeur booléenne nulle, à défaut il prend la valeur booléenne unité. Le critère de comparaison n'est pas vérifié dès qu'un écart entre deux données prend la valeur unité.
Selon la variante précitée, l'unité de vote 16 compare chaque donnée convertie du second ensemble Dout2_conv avec la donnée correspondante du premier ensemble de données Doutl .
Si les premier et second ensembles de données de sortie Doutl , Dout2 vérifient le critère de comparaison, le signal de vote S prend la valeur nulle. Dans le cas contraire, le signal de vote S prend la valeur unité.
A l'étape 180, l'unité de vote 16 transmet vers l'interface de sortie 18 le premier ensemble de données de sortie Doutl en tant que données de sortie en sécurité Dout, ainsi que le signal de vote S généré lors de l'étape 170.
A l'étape 190, l'interface de sortie 18 affiche les données de sortie en sécurité Dout qui lui ont été transmises, ainsi que le signal de vote S. Le signal de vote S est par exemple inclus dans les données (par exemple valeur explicite, codage des données) ou séparé des données.
Dans le mode de réalisation précédent, la conversion du type entier vers le type flottant s'effectue au niveau du langage du code source via la génération du code source intermédiaire L0', celui-ci étant ensuite compilé.
De préférence, les données de sortie Dout présentent un niveau de sécurité conforme au niveau SIL4 de la norme généraliste IEC61508 et au niveaux inférieurs (SILO à SIL3) de celui-ci ou conforme aux niveaux: SILO à SIL4 de la norme sectorielle EN50129 ou conforme aux niveaux Class2 à Classl de la norme sectorielle IEC61513.
En variante, cette conversion du type entier vers le type flottant s'effectue directement lors de la compilation du code source L0. Le compilateur comporte alors, par exemple, une option de compilation permettant d'activer un module de l'éditeur de lien propre, à chaque fois qu'une variable entière est déclarée dans le code source L0, à utiliser un fichier de la librairie qui correspond au type flottant, au lieu d'utiliser le fichier de la librairie qui correspond au type entier.
La présente invention s'applique à tout logiciel, mais est particulièrement bien adaptée au cas d'un logiciel de sécurité travaillant sur des variables entières. En conséquence, lors de l'exécution d'un exécutable résultant de la simple compilation du code source d'un logiciel de sécurité, le microprocesseur utilise uniquement son unité arithmétique pour les entiers. De plus, en convertissant systématiquement le type des variables afin de mettre en œuvre une redondance de traitement, on garantit que le microprocesseur utilisera uniquement son unité arithmétique pour les flottants lors de la mise en œuvre de la redondance du traitement. De cette manière, par une redondance du type des variables utilisées, à savoir le type entier pour le premier exécutable L1 et le type flottant pour le deuxième exécutable L2, le procédé de traitement selon l'invention permet la redondance du traitement des données par une diversification des moyens de traitement, et améliore ainsi la fiabilité des données délivrées à l'issue du traitement.
Les inventeurs ont constaté avec surprise que le type flottant double précision IEEE-754 était particulièrement adapté comme type particulier de flottant pour la mise en œuvre du procédé selon l'invention, alors que ce type de flottant n'est habituellement pas utilisé pour faire de la logique booléenne ou de l'arithmétique entière. En effet, la partie de mantisse des flottants double précisions, par exemple suivant la norme IEEE-754, permet de représenter de façon exacte les entiers codés sur 32 bits. Les nombres entiers sur 32 bits ont donc toujours une représentation exacte dans le type flottant double précision IEEE-754, puisque le nombre de bits qui les composent, à savoir 32, est strictement inférieur à 52 bits qui est le nombre de bits composant la mantisse des flottants double précisions IEE-754.
Le type flottant simple précision IEEE-754 avec ses 23 bits de mantisse permet de représenter de façon exacte les entiers codés sur 8 ou 16 bits.

Claims

REVENDICATIONS
1 . Procédé de traitement de données, mis en œuvre par un calculateur (10) comportant un compilateur (19),
le procédé de traitement comprenant les étapes suivantes :
une première étape (1 10) de génération d'un premier exécutable (L1 ) à partir d'un code source (L0) correspondant à un logiciel ;
une deuxième étape (120 ; 130) de génération d'un second exécutable (L2) à partir du même code source (L0) ;
le premier exécutable généré (L1 ) étant destiné à être exécuté par une première unité de traitement (30) et le deuxième exécutable généré (L2) étant destiné à être exécuté par une deuxième unité de traitement (32), distincte de la première unité de traitement (30),
le procédé de traitement étant caractérisé en ce que le code source (L0) comporte au moins une variable du type entier et, lors de l'étape (120 ; 130) de génération du second exécutable (L2), le type entier de la ou chaque variable est converti en type flottant.
2.- Procédé selon la revendication 1 , dans lequel l'étape de génération du premier exécutable (L1 ) consiste à compiler ledit code source (L0) à l'aide du compilateur (19, 62).
3. - Procédé selon la revendication 2, dans lequel l'étape de génération du second exécutable consiste à créer (120) un code source intermédiaire (L0') en remplaçant, dans ledit code source (L0), chaque déclaration d'une variable du type entier par la déclaration d'une variable du type flottant, puis à compiler (130) ledit code source intermédiaire (L0') en utilisant le compilateur (19, 62) mis en œuvre lors de l'étape (1 10) de génération du premier exécutable (L1 ).
4. - Procédé selon la revendication 2, dans lequel l'étape de génération du second exécutable (L2) consiste à compiler ledit code source (L0) en associant, à la ou chaque variable du type entier, un fichier d'une librairie (64) correspondant à un type flottant.
5. - Procédé selon l'une quelconque des revendications précédentes, dans lequel, une unité de calcul (14) comportant lesdites première et seconde unités de traitement (30, 32), le procédé comprend en outre les étapes suivantes :
une étape (140) d'exécution par l'unité de calcul (14) du premier exécutable (L1 ) pour le traitement d'un ensemble de données d'entrée (Din) afin de générer un premier ensemble de données de sortie (Doutl ) ;
une étape (150) d'exécution par l'unité de calcul (14) du second exécutable (L2) pour le traitement dudit ensemble de données d'entrée (Din) afin de générer un second ensemble de données de sortie (Dout2) ; et
- une étape (160 ; 170) de vote par une unité de vote (16) consistant à générer un signal de vote (S) en fonction du résultat d'une comparaison entre les premier et second ensembles de données de sortie (Doutl , Dout2).
6. - Procédé selon la revendication 5, dans lequel l'étape de génération du signal de vote (S) comprend :
- la conversion (160) du premier ensemble de données de sortie (Doutl ), les données du type entier étant converties en données de sortie du type flottant ;
- la comparaison de chaque donnée de sortie convertie (Dout1_conv) avec une donnée correspondante du second ensemble de données de sortie (Dout2).
7. - Procédé selon la revendication 5, dans lequel l'étape de génération d'un signal de vote (S) comprend :
- la conversion du second ensemble de données de sortie (Dout2), les données du type flottant étant converties en données de sortie du type entier ;
- la comparaison de chaque donnée de sortie convertie avec une donnée correspondante du premier ensemble de données de sortie (Doutl ).
8. - Procédé selon l'une quelconque des revendications précédentes, dans lequel le type flottant est un flottant double précision conforme à la norme IEEE-754.
9. - Procédé selon l'une quelconque des revendications précédentes, dans lequel chaque variable du code source (L0) est du type entier.
10. - Procédé selon la revendication 9 prise avec la revendication 5, dans lequel ladite première unité de traitement est une unité arithmétique pour les entiers (30) dédiée aux opérations sur des variables du type entier et ladite seconde unité de traitement est une unité arithmétique pour les flottants (32) dédiée aux opérations sur des variables du type flottant, et
dans lequel l'étape d'exécution (140) du premier exécutable (L1 ) est effectuée par l'unité arithmétique pour les entiers (30) et la étape d'exécution (150) du second exécutable (L2) est effectuée par l'unité arithmétique pour les flottants (32).
1 1 .- Procédé selon l'une quelconque des revendications précédentes, dans lequel le procédé comporte en outre une étape (190) de délivrance de données de sortie (Dout) correspondant au premier ensemble de données de sortie (Doutl ), et les données de sortie (Dout) présentent un niveau de sécurité conforme au niveau SIL4 de la norme généraliste IEC61508 et au niveaux inférieurs (SILO à SIL3) de celui-ci ou conforme aux niveaux: SILO à SIL4 de la norme sectorielle EN50129 ou conforme aux niveaux Class2 à Classl de la norme sectorielle IEC61513.
12.- Calculateur (10) comprenant un compilateur (19), le compilateur (19) comportant un module (62) de génération d'un premier exécutable (L1 ) à partir d'un code source (L0) correspondant à un logiciel, et des moyens (60, 62 ; 62) de génération d'un second exécutable (L2) à partir du même code source (L0),
le premier exécutable généré (L1 ) étant destiné à être exécuté par une première unité de traitement (30) et le deuxième exécutable généré (L2) étant destiné à être exécuté par une deuxième unité de traitement (32), distincte de la première unité de traitement (30),
caractérisé en ce que le code source (L0) comporte au moins une variable du type entier, et en ce que les moyens de génération (60, 62) sont propres à convertir le type entier de la ou chaque variable en type flottant lors de la génération du second exécutable (L2).
13.- Calculateur (10) selon la revendication 12, dans lequel le calculateur (10) comprend en outre une unité de calcul (14) comportant lesdites première et seconde unités de traitement (30, 32) et une unité de vote (16),
l'unité de calcul (14) étant propre à exécuter, d'une part, le premier exécutable (L1 ) pour le traitement d'un ensemble de données d'entrée (Din) afin de générer un premier ensemble de données de sortie (Doutl ), et d'autre part, le second exécutable (L2) pour le traitement dudit ensemble de données d'entrée (Din) afin de générer un second ensemble de données de sortie (Dout2) ; et l'unité de vote (16) étant propre à générer un signal de vote (S) en fonction du résultat d'une comparaison entre les premier et second ensembles de données de sortie (Doutl , Dout2).
EP13732927.2A 2012-06-29 2013-06-28 Procédé de traitement de données en sécurité, et calculateur associé Ceased EP2867774A1 (fr)

Applications Claiming Priority (2)

Application Number Priority Date Filing Date Title
FR1256229A FR2992749B1 (fr) 2012-06-29 2012-06-29 Procede de traitement de donnees en securite, et calculateur associe
PCT/EP2013/063712 WO2014001543A1 (fr) 2012-06-29 2013-06-28 Procédé de traitement de données en sécurité, et calculateur associé

Publications (1)

Publication Number Publication Date
EP2867774A1 true EP2867774A1 (fr) 2015-05-06

Family

ID=47294933

Family Applications (1)

Application Number Title Priority Date Filing Date
EP13732927.2A Ceased EP2867774A1 (fr) 2012-06-29 2013-06-28 Procédé de traitement de données en sécurité, et calculateur associé

Country Status (3)

Country Link
EP (1) EP2867774A1 (fr)
FR (1) FR2992749B1 (fr)
WO (1) WO2014001543A1 (fr)

Families Citing this family (2)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
DE102015204337A1 (de) * 2015-03-11 2016-09-15 Siemens Aktiengesellschaft Sicherheitsrelevantes Computersystem
EP3629177B1 (fr) * 2018-09-28 2021-09-01 Sick Ag Procédé de vérification du fonctionnement d'un moyen de traitement de données électronique

Family Cites Families (3)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US7613950B2 (en) * 2004-02-27 2009-11-03 Hewlett-Packard Development Company, L.P. Detecting floating point hardware failures
DE102008043374A1 (de) 2008-10-31 2010-05-06 Robert Bosch Gmbh Vorrichtung und Verfahren zur Generierung redundanter, aber unterschiedlicher Maschinencodes aus einem Quellcode zur Verifizierung für ein sicherheitskritisches System
CN102713857B (zh) * 2010-08-03 2014-11-26 西门子公司 用于进行故障安全型硬件无关浮点运算的方法和装置

Non-Patent Citations (2)

* Cited by examiner, † Cited by third party
Title
None *
See also references of WO2014001543A1 *

Also Published As

Publication number Publication date
FR2992749B1 (fr) 2014-08-08
WO2014001543A1 (fr) 2014-01-03
FR2992749A1 (fr) 2014-01-03

Similar Documents

Publication Publication Date Title
CN109523383B (zh) 一种智能合约转换系统及方法
US20190265955A1 (en) Method and system for comparing sequences
EP1387261A1 (fr) Logiciel de generation de code d'application informatique et langage de description de logiciel
EP2453356B1 (fr) Procédé, programme d'ordinateur et dispositif de sécurisation de code intermédiaire de programmation pour son exécution par une machine virtuelle
WO2020190546A1 (fr) Quantification de valeurs aberrantes pour l'apprentissage et l'inférence
EP2860656B1 (fr) Procédé d'exécution par un microprocesseur d'un code binaire polymorphique d'une fonction prédéterminée
EP3503103A1 (fr) Système comportant une mémoire adaptée à mettre en oeuvre des opérations de calcul
CA2656125C (fr) Dispositif et procede d'encodage de type cabac
Beaulieu et al. Fossils do not substantially improve, and may even harm, estimates of diversification rate heterogeneity
EP2867774A1 (fr) Procédé de traitement de données en sécurité, et calculateur associé
FR3021769A1 (fr) Dispositif et procede de generation d'au moins un fichier informatique pour la realisation d'une interface graphique d'un equipement electronique, et produit programme d'ordinateur associe
EP4057271B1 (fr) Procédé de test d'un dispositif électroportatif
US20170083637A1 (en) Condition analysis
EP3195113B1 (fr) Procédé de vérification de traçabilité de premières instructions en un langage de programmation procédurale générées à partir de secondes instructions en un langage de modélisation
FR2700032A1 (fr) Procédé de détection des erreurs d'exécution d'un logiciel.
EP3005107A1 (fr) Accelerateur materiel pour la manipulation d'arbres rouges et noirs
EP2959382B1 (fr) Systeme de compilation dynamique d'au moins un flot d'instructions
CN114647407A (zh) 一种实现复杂分支逻辑调用的方法、装置及存储介质
CN114610513B (zh) 一种故障数据的处理方法、装置及设备
EP1089175A1 (fr) Système informatique sécurisé
CN111338318B (zh) 用于检测异常的方法和装置
Hoang et al. Rethinking Output Alignment For 1-bit Post-Training Quantization of Large Language Models
FR2828296A1 (fr) Procede de compression de code objet interprete par factorisation d'expressions arborescentes
WO2025133271A1 (fr) Procede et systeme informatique pour l'evaluation en temps-reel d'expressions matricielles d'un code
FR3160023A1 (fr) Procede et dispositif d’evaluation de la qualite d’execution apres traduction d’un logiciel

Legal Events

Date Code Title Description
PUAI Public reference made under article 153(3) epc to a published international application that has entered the european phase

Free format text: ORIGINAL CODE: 0009012

17P Request for examination filed

Effective date: 20150129

AK Designated contracting states

Kind code of ref document: A1

Designated state(s): AL AT BE BG CH CY CZ DE DK EE ES FI FR GB GR HR HU IE IS IT LI LT LU LV MC MK MT NL NO PL PT RO RS SE SI SK SM TR

AX Request for extension of the european patent

Extension state: BA ME

DAX Request for extension of the european patent (deleted)
RAP1 Party data changed (applicant data changed or rights of an application transferred)

Owner name: ALSTOM TRANSPORT TECHNOLOGIES

17Q First examination report despatched

Effective date: 20170710

REG Reference to a national code

Ref country code: DE

Ref legal event code: R003

18R Application refused

Effective date: 20180517