EP3639140A1 - Dispositif de caracterisation et/ou de modelisation de temps d'execution pire-cas - Google Patents

Dispositif de caracterisation et/ou de modelisation de temps d'execution pire-cas

Info

Publication number
EP3639140A1
EP3639140A1 EP18737666.0A EP18737666A EP3639140A1 EP 3639140 A1 EP3639140 A1 EP 3639140A1 EP 18737666 A EP18737666 A EP 18737666A EP 3639140 A1 EP3639140 A1 EP 3639140A1
Authority
EP
European Patent Office
Prior art keywords
characterization
execution
execution time
configuration data
processor
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.)
Pending
Application number
EP18737666.0A
Other languages
German (de)
English (en)
Inventor
Liliana CUCU-GROSJEAN
Adriana GOGONEL
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.)
Institut National de Recherche en Informatique et en Automatique INRIA
Original Assignee
Institut National de Recherche en Informatique et en Automatique INRIA
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 Institut National de Recherche en Informatique et en Automatique INRIA filed Critical Institut National de Recherche en Informatique et en Automatique INRIA
Publication of EP3639140A1 publication Critical patent/EP3639140A1/fr
Pending legal-status Critical Current

Links

Classifications

    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F11/00—Error detection; Error correction; Monitoring
    • G06F11/30—Monitoring
    • G06F11/34—Recording or statistical evaluation of computer activity, e.g. of down time, of input/output operation ; Recording or statistical evaluation of user activity, e.g. usability assessment
    • G06F11/3452—Performance evaluation by statistical analysis
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F30/00—Computer-aided design [CAD]
    • G06F30/20—Design optimisation, verification or simulation
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F11/00—Error detection; Error correction; Monitoring
    • G06F11/30—Monitoring
    • G06F11/34—Recording or statistical evaluation of computer activity, e.g. of down time, of input/output operation ; Recording or statistical evaluation of user activity, e.g. usability assessment
    • G06F11/3409—Recording or statistical evaluation of computer activity, e.g. of down time, of input/output operation ; Recording or statistical evaluation of user activity, e.g. usability assessment for performance assessment
    • G06F11/3419—Recording or statistical evaluation of computer activity, e.g. of down time, of input/output operation ; Recording or statistical evaluation of user activity, e.g. usability assessment for performance assessment by assessing time
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06N—COMPUTING ARRANGEMENTS BASED ON SPECIFIC COMPUTATIONAL MODELS
    • G06N7/00—Computing arrangements based on specific mathematical models
    • G06N7/01—Probabilistic graphical models, e.g. probabilistic networks
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F2111/00—Details relating to CAD techniques
    • G06F2111/10—Numerical modelling
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F2119/00—Details relating to the type or aim of the analysis or the optimisation
    • G06F2119/12—Timing analysis or timing optimisation

Definitions

  • the invention relates to the field of the design of embedded systems and the simulation of their operation.
  • Critical embedded systems have the particular feature of being designed so as to know no fault and / or to have a very high tolerance in case of occurrence of a fault.
  • the resources of these systems are doubled, tripled or even increased, so as to ensure redundancy in case of failure of one of the elements, as well as to ensure that all the calculations that these systems are responsible for performing are completed in the desired times.
  • the invention improves the situation.
  • the invention proposes a computing device for characterizing execution time by a processor, comprising a memory arranged to receive bench program data, characterization configuration data sets and case data sets. , and an arranged constructor, for each execution case data set, for determining a worst-case configuration data set of the processor and a set of initialization values from a case data set of execution, and determine a reference execution time by executing the bench program according to the execution case data set by the processor configured with the configuration data set with the set of initialization values, the set of reference execution times forming a set of reference execution times.
  • the constructor is furthermore arranged, for each characterization configuration data set, to determine a set of characterization execution times, each characterization execution time set comprising a number of characterization execution times equal to number of elements of the reference execution time set and each characterization execution time being determined by executing the bench program by the configured processor with a characterization configuration data set and a set of initialization values representative of the bench program and the processor, and for determining a set of characterization coefficients by applying a maximum likelihood determination algorithm between the reference run time set and the character run time sets.
  • the device is finally arranged to return the characterization configuration data set and the set of characterization coefficients.
  • the device may have one or more of the following characteristics:
  • the constructor is arranged to calculate the characterization coefficients by determining, for each set of characterization execution times, a plurality of estimation vectors in which, for each index, the value is zero or equal to one if the time of Index characterization execution is the closest to the reference execution time for this index among all the characterization execution times for this index, as well as a variance for each characterization execution time set to from the plurality of estimation vectors and the differences between the reference execution times and the identical index characterization execution times, and then calculating iteratively from a sliding window comprising for each iteration and for each characterization execution time set a number of execution times equal to the number of elements of the reference execution time set and which are the most recent:
  • a plurality of estimators for the current iteration from a plurality of normal laws for each set of characterization execution times that have in common a variance derived from that of the previous iteration, and whose average is drawn each time from a characterization runtime selected by the sliding window of the current iteration, which normal law are each evaluated at the execution time of the reference execution time set corresponding to the one from which the average is determined,
  • a new characterization execution time for each characterization execution time set by applying a normal law whose variance is that calculated for each characterization execution time set for the current iteration and the average is the highest index characterization run time in the sliding window, which normal law is evaluated at the run time of the highest index reference time set in the sliding window, and a new time of reference execution from the new characterization runtimes for each characterization runtime set and the characteristic coefficients for each characterization runtime set for the current iteration,
  • the iterations being repeated until a condition relating to the number of iterations or a difference between the characterization coefficients for each set of consecutive iteration characterization run times is fulfilled, the set of coefficients characterization being defined from the characterization coefficients of the last iteration,
  • the constructor is arranged to calculate the estimators according to the following formula:
  • each z is an element of index i in the estimator z
  • N denotes the normal law of mean m and of variance s
  • Mk denotes the execution time of index i in the k-th time set of Characterization execution
  • sig is the variance for the k-th characterization runtime set
  • Mo designates the index execution time i in the reference run time set
  • z is the index element i in the z-estimator for the k-th characterization runtime set
  • Mk is the index execution time i in the k-th time-set of characterization execution
  • Mo denotes the index execution time i in the reference execution time set
  • N denotes the normal law of mean m and variance s
  • Mk denotes the execution time of index i in the k-th characterization run time set
  • sig is the variance for the k-th set characterization run time
  • the constructor is arranged to calculate the new reference execution times according to the following formula:
  • Mo denotes the index execution time i in the reference execution time set
  • Mk denotes the index execution time i in the k-th characterization execution time set
  • alph is the characterization coefficient associated with the kth characterization runtime set in the ith iteration.
  • the invention also relates to a device for calculating a worst-case execution time base of a program by a processor comprising a memory arranged to receive program data, configuration data sets of characterization and a set of characterization coefficients obtained by the execution of the device described above, and a modeler arranged for:
  • the device may have one or more of the following characteristics:
  • modeler is furthermore arranged to extrapolate worst-case execution times
  • the modeler is further arranged to determine a worst-case execution time with a corresponding probability by applying a pWCET algorithm to the worst-case execution time base.
  • the invention also relates to a method for characterizing execution time by a processor, comprising the following operations:
  • each characterization configuration data set determining a characterization execution time set, each characterization execution time set comprising a number of characterization execution times equal to the number of elements of the game of reference execution time and each characterization execution time being determined by executing the bench program by the configured processor with a characterization configuration data set and with a set of initialization values representative of the bench program and the processor,
  • the method may have one or more of the following characteristics:
  • the operation d) comprises calculating the characterization coefficients by determining, for each set of characterization execution times, a plurality of estimation vectors in which, for each index, the value is zero or equal to one if the time index characterization runtime is the closest to the reference execution time for this index among all the characterization runtimes for that index, plus a variance for each characterization runtime set from the plurality of estimation vectors and the differences between the reference execution times and the identical index characterization execution times, and then computing iteratively from a sliding window comprising for each iteration and for each set of characterization runtimes a number of equal execution times the number of elements in the reference runtime set that are the most recent:
  • a plurality of estimators for the current iteration from a plurality of normal laws for each set of characterization execution times that have in common a variance derived from that of the previous iteration, and whose average is each time a characterization execution time selected by the sliding window of the current iteration, which normal laws are each evaluated at the execution time of the reference execution time set corresponding to that from which is the average,
  • a new characterization execution time for each characterization execution time set by applying a normal law whose variance is that calculated for each characterization execution time set for the current iteration and the average is the highest index characterization run time in the sliding window, which normal law is evaluated at the run time of the highest index reference time set in the sliding window, and a new time of reference execution from the new characterization runtimes for each characterization runtime set and the characteristic coefficients for each characterization runtime set for the current iteration,
  • the iterations being repeated until a condition relating to the number of iterations or a difference between the characterization coefficients for each set of consecutive iteration characterization run times is fulfilled, the set of coefficients characterization being defined from the characterization coefficients of the last iteration,
  • the operation d) comprises calculating the estimators according to the following formula:
  • each z is an element of index i in the estimator z
  • N denotes the normal law of mean m and of variance s
  • Mk denotes the execution time of index i in the k-th time set of Characterization execution
  • sig is the variance for the k-th characterization runtime set
  • Mo designates the index execution time i in the reference run time set
  • operation d) comprises calculating the variances according to the following formula:
  • z is the index element i in the z-estimator for the k-th characterization runtime set
  • Mk is the index execution time i in the k-th time-set of characterization execution
  • Mo denotes the index execution time i in the reference execution time set
  • the operation d) comprises calculating the characterization coefficients according to the following formula:
  • the operation d) comprises calculating the new characterization execution times according to the following formula:
  • N denotes the normal law of mean m and variance s
  • Mk denotes the execution time of index i in the k-th characterization run time set
  • sig is the variance for the k-th set characterization run time
  • operation d) comprises calculating the new reference execution times according to the following formula:
  • Mo denotes the index execution time i in the reference execution time set
  • Mk denotes the index execution time i in the k-th characterization execution time set
  • alph is the characterization coefficient associated with the kth characterization runtime set in the ith iteration.
  • the invention also relates to a method for calculating a worst-case execution time base of a program by a processor comprising a) receiving program data, characterization configuration data sets and a set of coefficients. characterization obtained by the execution of the device or method described above,
  • a worst-case execution time base a plurality of worst-case execution times, which are each equal to the sum for each of the product characterization configuration data sets of one of the worst-case execution times. executions by the characterization coefficient associated with the characterization configuration data set which made it possible to obtain this execution time, so that the worst-case execution time base comprises a number of equal execution times the number of sets of initialization values for each characterization configuration data set.
  • the method may have one or more of the following characteristics:
  • FIG. 1 represents a schematic diagram of a device according to the invention
  • FIG. 2 represents an exemplary implementation of a function by an element of FIG. 1,
  • FIG. 3 represents an exemplary implementation of a function of FIG. 2,
  • FIG. 4 represents an exemplary implementation of a function of FIG. 2,
  • FIG. 5 represents an exemplary implementation of a function of FIG. 2,
  • FIG. 6 represents an exemplary implementation of a function by an element of FIG. 1, and
  • FIG. 7 represents an exemplary implementation of a function of FIG. 6.
  • Figure 1 shows a device 2 according to the invention in its environment.
  • the device 2 comprises a manufacturer 4, a modeler 6 and a memory 8.
  • the memory 8 can be any type of data storage suitable for receiving digital data: hard disk, hard disk flash memory (SSD in English), flash memory in any form, RAM, disk magnetic, distributed storage locally or in the cloud, etc.
  • the data calculated by the device can be stored on any type of memory similar to or on memory 8. This data can be erased after the device has completed its tasks or stored.
  • the data stored in the memory 8 is program data to be tested, sets of processor factors and n-tuples representing execution times of a given program by a processor configured with a given set of factors. In the example described here, these data are calculated by the modeler 6. Alternatively, they could be obtained differently. The data stored in the memory 8 could also be arranged in another form.
  • the constructor 4 and the modeler 6 are elements directly or indirectly accessing the memory 8. They can be made in the form of an appropriate computer code executed on one or more processors. By processors, it must be understood any processor adapted to the calculations described below. Such a processor can be made in any known manner, in the form of a microprocessor for a personal computer, a dedicated FPGA or SoC chip ("System on chip"), a computing resource on a grid, a microcontroller, or any other form to provide the computational power necessary for the embodiment described below. One or more of these elements can also be realized in the form of specialized electronic circuits such as an ASIC. A combination of processor and electronic circuits can also be considered.
  • the function of constructor 4 is to determine a set of coefficients stored in an vector alph []. This set of coefficients is determined on the basis of a benchmark program for a processor that is to be characterized, as well as for a set of processor factors chosen for the processor that is to be characterized.
  • a processor may be characterized by certain factors that will affect its operation. For example, these factors may be the activation state of one or more of the processor cores and / or their operating frequency, the operating state of one or more low-level RAMs, the state of of operation of one or more of the communication buses within the processor, the operating status of one or more of the processor buffers, the activation state of specific data processing functions, etc.
  • the constructor 4 will determine a worst case execution time data set for the bench program for the given processor in a worst case configuration, as well as for each of the processor factor sets.
  • the coefficient set will be computed to represent a match between the runtime data sets associated with each of the processor factor sets and the worst case run time set.
  • the role of the modeller 6 is to exploit the set of coefficients.
  • the modulator 6 receives simulation data 10 comprising program data to be qualified, the program to be qualified being considered sufficiently similar to the bench program.
  • the simulation data is used with the processor factor sets to determine run time data sets of the program to be qualified for each of the processor factor sets, and then the coefficient set is used to generate a set of processor factors. worst case execution time data for the program to qualify.
  • This worst case execution time data set can then be extended in a synthetic manner to generate a large number of execution times which are characteristic of the execution of the program to be qualified by the given processor under worst case conditions.
  • This extended data is stored in worst case data 12 which can be used in accordance with what has been described in the patent application. French FR 15 51828 (or in another way) to determine a worst case execution time by the given processor for the program to qualify.
  • the time to get the worst case runtime data set and its extension is much shorter than the time that would be needed to directly acquire runtimes for that same program by running it on the given processor for all events.
  • the modeler 6 makes it possible to obtain a worst case execution data set comprising a very large number of data much faster than was previously possible. This is achieved by performing the most intensive computation amount only once to compute the coefficient set, and reusing them to qualify all subsequent programs, as long as they are sufficiently similar to the bench program.
  • the device 2 can comprise the manufacturer 4 and the modeler 6 together, or only one of them.
  • the modeler 6 could receive, in addition to the simulation data 10, data containing the set of coefficients as well as sets of processor factors.
  • the device of the invention can be used in other applications than the determination of "worst-case" time of a task by a processor, since it is a question of studying the taking of values extremes of a physical parameter.
  • the constructor 4 and the modeler 6 can be made in a great many ways and be, for example, coded in the form of a computer program.
  • FIG. 2 represents an example of a function implemented by the manufacturer 4 to calculate the set of coefficients.
  • the constructor 4 executes a function Trnl () to calculate the worst execution time data set case for the program bench for the processor given in a worst case configuration.
  • Figure 3 shows an example of implementation of the function Trnl ().
  • an index i is initialized to zero, and the bench program B and the processor P are received.
  • a function Cas () receiving the program B bench is executed in order to determine all the possible execution cases for the program bench B.
  • These possible execution cases are stored in a vector J.
  • the program bench and cut automatically or manually into a plurality of call blocks interconnected by a sequencing graph of the program bench B, and the execution cases are generated taking into account the various hardware possibilities of execution of these call blocks, on all possible combinations of call blocks within the sequencing graph of the program bench B.
  • the vector J can be received as a parameter, for example by the user.
  • a loop is then started from an operation 320 in which the set of executions cases traveled and executed by the processor in order to derive a worst case execution time.
  • the vector J is unstacked in a variable S
  • the set of processor factors F is determined in an operation 330
  • the processor is initialized in an operation 340
  • a vector of initialization values V is generated by a function Rand () which receives the variable S as an argument in an operation 350.
  • the function Rand () generates the vector of initialization values V randomly.
  • the function Rand () could define the vector of initialization values V by choosing it from a group of vectors that are statistically representative with respect to the execution case S on the processor P.
  • a function Wc () receiving the processor P and the variable S as arguments is executed in order to determine a set of processor factors F corresponding to the worst-case operation for the processor P in the execution case S.
  • the function Wc () will generate a set of processor factors in which a only cores are enabled, with a minimum operating frequency, disabling the buffers, and providing a malfunction of the communication bus on the processor.
  • the set of processor factors F can be received as a parameter, for example by the user.
  • An Init () function is then executed in the operation 340 with the processor P and the set of processor factors F as arguments. This function accesses the processor P and configures it according to processor factor set F.
  • the operation 350 can be performed after the operation 340, before it or in parallel.
  • the worst-case execution time corresponding to the variable S is determined by executing an Ex () function in an operation 360.
  • the Ex () function executes the execution case defined by the variable S with the initialization value vector V on the processor P initialized at operation 340.
  • the resulting execution time is stored in the worst execution time data set case M0 [i], then the index i is incremented in an operation 370 and the loop resumes with the operation 340.
  • the function Trnl () ends in an operation 399 with the return of the worst execution time data set case MO.
  • Constructor 4 then executes a function Trn2 () in an operation 210 in which it determines a plurality of respective run time data sets at sets of processor factors selected from a set of processor factor sets.
  • the set of processor factor sets is chosen so as to characterize the worst-case behavior of the processor P, in the manner of the eigenvectors of a matrix.
  • each set of processor factors is defined by activating and / or optimizing one or more factors of the processor P, and setting all other factors to their worst case value.
  • Figure 4 shows an example of implementation of the function Trn2 ().
  • an index i is initialized to zero, and the set of processor factor sets F, the bench program B, the processor P are received, as well as the worst execution time data set case MO.
  • the set of processor factor sets F received in operation 400 is distinct from that determined in operation 330.
  • each set of factors of the set of processor factor sets F represents a configuration that the function aims to qualify.
  • a variable T is created and receives the number of execution times contained in the worst execution time data set case MO.
  • a variable K is created and receives the number of sets of processor factors contained in the set of processor factor sets F.
  • a loop is then started in which a set of runtime data sets M1 to MK will be generated for each set of processor factors, each runtime data set M1 to MK receiving a number of times of execution time. execution equal to variable T.
  • the index k of the processor factor set for which an execution time has to be determined for a given instance of the loop is determined in an operation 430 by calculating the index i modulo the variable K.
  • the index j of the execution time in the execution time data set Mk is determined for a given instance of the loop is determined in an operation 440 by calculating the integer part of the division of the index i by the variable T.
  • the operations 430 and 440 have the consequence that the execution time data sets Mk are determined increasingly, one execution time at a time. This can be done in another order, since a hazard is preserved so as not to bias the construction of the execution time data sets Mk.
  • the processor P is initialized with the set of index processor factors k in the set of processor factor sets in an operation 450 similar to operation 340, then a vector of initialization values V is generated by applying a function Rand2 () to the program B bench in an operation 460 similarly to the operation 350.
  • the function Rand2 () generates the vector of initialization values V randomly
  • the function Rand2 () could define the vector of initialization values V by choosing it from a group of vectors that are representative of a statistical point of view compared to the execution case S on the processor P.
  • the worst case execution time corresponding to the initialization value vector V is determined by executing an Ex () function in an operation 470.
  • the Ex () function executes the execution case defined by the vector of values d initialization V for the program B bench on the processor P initialized in operation 450.
  • the resulting execution time is stored in the execution time data set Mk [j], then the index i is tested in an operation 480 to determine if all the execution time data sets Mk have been calculated. .
  • Constructor 4 then executes a function Fit () in an operation 220 in which it determines a set of coefficients alph [] which characterizes the correspondence between each of the execution time datasets M1 to MK with the time data set. worst case execution MO.
  • Bayesian Model Averaging Bayesian Model Averaging
  • the probability distribution function of a prediction on the basis of a plurality of models M1 to MK for explaining an MO model, may perhaps be written according to the formula [10] of Annex A.
  • the Applicant's work has revealed that by correcting the bias of the execution time data sets M1 to MK, these can be rewritten as predictors f1 to fk, which makes it possible to define a distribution function. of conditional probability on each predictor fk, and to rewrite the formula [10] according to the formula [20] of Appendix A.
  • each conditional probability distribution function on a predictor fk can then be approximated by means of of a normal distribution centered on a linear function of the predictor fk.
  • the determination of the set of normal laws on the basis of the predictors fk then makes it possible to determine all the coefficients of the vector alph [].
  • the Applicant uses the likelihood function of which it maximizes the logarithm according to the EM algorithm ("The EM algorithm and extensions” by Geoffrey J. McLachlan, and Thriyambakam Krishnan, 1997) which is an extension of the article " Maximum Likelihood from Incomplete Data via the EM Algorithm "by Dempster, Laird and Rubin in Journal of the Royal Statistical Society. Series B (Methodological), Vol. 39, No. 1. (1977), pp. 1- 38. This is done using the formula [30] of Appendix A.
  • Figure 5 shows an exemplary implementation of the function for determining the vector alph [] for the execution time data sets M1-MK with respect to the runtime data set MO.
  • the run time data sets MO to MK are received, as well as the number T of data in each run time dataset, and an index j is initialized to 1.
  • the algorithm is initialized by calculating an estimator z (0) and a variance vector sig (0) by means of a function Min ().
  • the function Min () receives the data sets MO to MK, and, for each execution time of each set Ml to MK, defines a value which it stores in z (0) which is equal to 1 if an execution time of given index is the closest among all the execution times of the same index of the execution time having this same index in MO.
  • z (0) (r, i) is equal to 1 if Mr (i) is the closest to M0 (i) among all Mk (i). All other z (0) (k, i) are set to 0.
  • each z (j) (k, i) is computed from the formula [50] of the appendix A, where N (X, Y) (z) denotes the normal distribution of mean X, of variance Y, calculated in z.
  • the index i is between j and T + j-1, and the index k is between 1 and K.
  • the vector z (j) therefore contains T * K values.
  • the vector sig (j) is then evaluated in an operation 530 by applying the formula [40] of Appendix A, and the weight vector alph (j) is evaluated in an operation 540 by applying the formula [60] of the 'Annex A.
  • the vectors sig (j) and alph (j) make it possible to define K normal laws determined on a window of index i between j and T + j-1 for each of the execution time data sets Mk for k between 1 and K.
  • a function M () is executed, which calculates at a first time a new execution time Mk (T + j) for each k between 1 and K by applying the formula [70] of Annex A, that is to say by applying the normal distribution whose parameters have just been evaluated for the execution time window of index k whose values are those associated with indices lying between j-1 and T + j-1, with as average the last execution time of this window (that is to say Mk (T + jl)), as the variance the index value k of the vector sig (j), evaluated at the point M0 (T + jl).
  • the runtime data set MO is also extended according to the formula [80] of Annex A.
  • a test is then performed in an operation 560 to determine if the vector alph (j) is sufficiently close to the vector alph (jl), which makes it possible to determine that the algorithm has converged. If it is not, then j is incremented in an operation 570. Otherwise, the function Fit () then ends by returning the set of coefficients alph [j] in an operation 599.
  • the length of the sliding window used is equal to T, that is to say the number of elements of MO. However, this length represents a maximum and could be lower.
  • the length of the sliding window could be chosen from criteria such as the Continous Rank Probability Score (CRPS) or the Root Mean Square Error (RMSE).
  • CRPS Continous Rank Probability Score
  • RMSE Root Mean Square Error
  • the operations 510, 530 and 550 may be adapted to a smaller length.
  • FIG. 6 represents an exemplary implementation of a computation time calculation function worst case for a program TP on the basis of the characterization that has just been made.
  • the worst-case execution time model for the program TP is determined by executing a function Use () which receives the program TP, the weight vector alph [] and the sets of factors F [ l] to F [K] as arguments.
  • Figure 7 shows an example of implementing the Use () function.
  • an index i is initialized to 0, and the sets of factors F, the new program TP, the processor P and the number of executions R are received.
  • K is determined as the number of factor sets F.
  • a loop is then executed to perform R executions of the new program TP on the processor P, initialized according to each set of factors F.
  • an index k is calculated in an operation 710 as the remainder of the index i modulo K, and indicates which set of factors will be used. Then, or in parallel, an index j is defined in an operation 715 as the integer part of the index i divided by K. This will indicate the rank of the determined execution time.
  • the function Rand () is executed with the new program TP to generate a vector of initialization values V, as for the operations 350 and 460.
  • the processor P is initialized in an operation 725 with the set of factors F [k] identically to operations 340 and 450, and in an operation 730 the program TP is executed on the processor P initialized with the vector of initialization values V and the corresponding execution time is stored in the vector Mk [] at index j.
  • a test of an operation 735 determines if i is strictly less than R. If this is the case, then it is incremented in an operation 740. If not, then the new program TP has been characterized and the model worst case ⁇ 0 is calculated in operations 745 to 775.
  • the index j is reset to 0.
  • a double loop is then started in which each index contribution j taken from each set of factors is grouped together to form a worst execution time index case j for the new TP program.
  • the index k is initialized to 0 in the operation 750, and all the sets of factors are traversed for the index j given by adding to MTP0 [j] the value Mk [j] multiplied by alph [k] in an operation 755.
  • MTP0 [j] progressively receives the contributions Mk [j] of each set of factors, a test in the operation 760 determines whether all the sets of factors have been traveled or not.
  • the index k is incremented in the operation 765 and the loop in k resumes with the operation 755. If it is the case, then a test in operation 770 determines if all lines of MTP0 [] have been satisfied. If it is not the case, then the index j is incremented in the operation 775 and the loop in i resumes with the operation 750. If it is the case, then the function ends in 799. Then, an Extr () function is executed in an operation 610 on the worst execution time set MTPO case. The Extr () function extrapolates additional data in order to complete the worst case execution time set MTPO. For this, it applies the normal laws of each set of factors F [1] to F [K] in sliding window, as it was done with the operation 550, except that the variance sig (k) is fixed for each set of factors.
  • a function pWCET calculates the worst case execution time with a corresponding probability with the result of the operation 630.
  • this function can be performed in accordance with the teachings of the French patent application FR 51828 or in any other suitable manner.
  • the invention therefore makes it possible to obtain results making it possible to determine the worst-case execution times of a program by a processor from a number of executions that is significantly lower than what was previously known (of the order 1,000 executions against more than 100,000 before). This makes it possible to modify the programs with greater certainty, since the question of validation of the latter by the processors is no longer a critical problem in terms of execution time. In addition, it also allows for comparison of processor banks for the execution of a given program. Indeed, it quickly becomes possible to compare the processors between them.

Landscapes

  • Engineering & Computer Science (AREA)
  • Physics & Mathematics (AREA)
  • Theoretical Computer Science (AREA)
  • General Engineering & Computer Science (AREA)
  • General Physics & Mathematics (AREA)
  • Computer Hardware Design (AREA)
  • Evolutionary Computation (AREA)
  • Probability & Statistics with Applications (AREA)
  • Quality & Reliability (AREA)
  • Geometry (AREA)
  • Computational Mathematics (AREA)
  • Data Mining & Analysis (AREA)
  • Software Systems (AREA)
  • Mathematical Physics (AREA)
  • Algebra (AREA)
  • Artificial Intelligence (AREA)
  • Computing Systems (AREA)
  • Pure & Applied Mathematics (AREA)
  • Mathematical Analysis (AREA)
  • Mathematical Optimization (AREA)
  • Evolutionary Biology (AREA)
  • Life Sciences & Earth Sciences (AREA)
  • Bioinformatics & Cheminformatics (AREA)
  • Bioinformatics & Computational Biology (AREA)
  • Debugging And Monitoring (AREA)
  • Complex Calculations (AREA)

Abstract

Un dispositif informatique de caractérisation de temps d'exécution par un processeur, comprend une mémoire (8) qui reçoit des données de programme banc, des jeux de données de configuration de caractérisation et des jeux de données de cas d'exécution, et un constructeur (4) qui détermine, pour chaque jeu de données de cas d'exécution, un jeu de données de configuration pire-cas du processeur et un jeu de valeurs d'initialisation à partir d'un jeu de données de cas d'exécution, et déterminer un temps d'exécution de référence en exécutant le programme banc selon le jeu de données de cas d'exécution par le processeur configuré avec le jeu de données de configuration avec le jeu de valeurs d'initialisation, l'ensemble des temps d'exécution de référence formant un jeu de temps d'exécution de référence. Le constructeur (4) détermine, pour chaque jeu de données de configuration de caractérisation, un jeu de temps d'exécution de caractérisation comprenant un nombre de temps d'exécution de caractérisation égal au nombre d'éléments du jeu de temps d'exécution de référence et chaque temps d'exécution de caractérisation étant déterminé en exécutant le programme banc par le processeur configuré avec un jeu de données de configuration de caractérisation et avec un jeu de valeurs d'initialisation représentatif du programme banc et du processeur. Le constructeur (4) détermine un jeu de coefficients de caractérisation en appliquant un algorithme de détermination du maximum de vraisemblance entre le jeu de temps d'exécution de référence (M0) et les jeux de temps d'exécution de caractérisation (M[k]), et le dispositif retourne le jeu de données de configuration de caractérisation et le jeu de coefficients de caractérisation..

Description

Dispositif de caractérisation et/ou de modélisation de temps d'exécution pire-cas
L'invention concerne le domaine de la conception des systèmes embarqués et la simulation de leur fonctionnement.
Plus particulièrement, l'invention trouve son application dans la conception des systèmes embarqués critiques. Les systèmes embarqués critiques présentent la particularité d'être conçus de manière à ne connaître aucune faille et/ou pour présenter une très haute tolérance en cas d'apparition d'une faille. Par exemple, les ressources de ces systèmes sont doublées, triplées, voire décuplées, de manière à assurer une redondance en cas de panne d'un des éléments, ainsi que pour s'assurer que tous les calculs que ces systèmes sont chargés de réaliser sont terminés dans les temps souhaités.
Historiquement, la progression technologique a été suffisante pour combler la complexifïcation croissante de ces systèmes. En d'autres termes, l'accroissement de puissance disponible pour les processeurs des systèmes embarqués rendait la conception simple : il suffisait de surdimensionner le pilote avec un coefficient important pour garantir l'intégrité de tous les systèmes embarqués, qu'il s'agisse d'avionique, d'aérospatiale, d'automobile ou de ferroviaire.
Dans les années récentes, deux effets combinés ont changé ce paradigme.
D'une part, bien que les puissances des pilotes continuent de s'accroître de manière régulière, cette croissance s'est ralentie et tend à se ralentir encore plus au fur et à mesure que la finesse de gravure augmente. Cela est accru par le fait que la consommation électrique et la chaleur dégagée sont des critères qui sont devenus cruciaux, alors que cela n'était pas le cas pour les anciens pilotes.
D'autre part, de grands progrès ont été réalisés en termes de modélisation physique et d'application pratique des systèmes embarqués, et les applications de ceux-ci exigent une puissance de calcul qui s'est grandement accrue, et qui tend à s'accroître plus vite que l'accroissement de la puissance des processeurs. Il existe donc un besoin de produire un dispositif qui permet de mieux dimensionner les besoins en puissance de calcul des systèmes embarqués.
Dans la demande de brevet français FR 15 51828, la Demanderesse a proposé un dispositif de simulation et un procédé qui permettent d'évaluer de manière précise un temps d'exécution « pire cas » avec un degré de certitude choisi.
Cela constitue une avance considérable dans le domaine, mais nécessite un jeu de données d'entrée qui caractérise suffisamment le processeur et le programme pour lequel le temps d'exécution pire cas est recherché. Pour produire ces temps d'exécution, il est donc nécessaire d'exécuter le programme sur le processeur un nombre de fois extrêmement important, pouvant aller au-delà de 100 000 d'occurrences. Le jeu de données d'entrée pour ces exécutions fait partie de domaine de définition de programme sur le processeur respectif. Ce domaine de définition étant souvent trop large pour être complètement visité on peut faire appel à des méthodes en utilisant des procédés aléatoires (par exemple Monte-Carlo) pour choisir un jeu de données de ce même domaine. Chaque jeu de données d'entrée étend caractéristiques d'un processeur et d'un programme donné, il est donc nécessaire de relancer la production du jeu de données d'entrée à chaque fois qu'un nouveau programme est considéré.
L'invention vient améliorer la situation. A cet effet, l'invention propose un dispositif informatique de caractérisation de temps d'exécution par un processeur , comprenant une mémoire agencée pour recevoir des données de programme banc, des jeux de données de configuration de caractérisation et des jeux de données de cas d'exécution, et un constructeur agencé, pour chaque jeu de données de cas d'exécution, pour déterminer un jeu de données de configuration pire-cas du processeur et un jeu de valeurs d'initialisation à partir d'un jeu de données de cas d'exécution , et déterminer un temps d'exécution de référence en exécutant le programme banc selon le jeu de données de cas d'exécution par le processeur configuré avec le jeu de données de configuration avec le jeu de valeurs d'initialisation, l'ensemble des temps d'exécution de référence formant un jeu de temps d'exécution de référence. Le constructeur est en outre agencé, pour chaque jeu de données de configuration de caractérisation, pour déterminer un jeu de temps d'exécution de caractérisation, chaque jeu de temps d'exécution de caractérisation comprenant un nombre de temps d'exécution de caractérisation égal au nombre d'éléments du jeu de temps d'exécution de référence et chaque temps d'exécution de caractérisation étant déterminé en exécutant le programme banc par le processeur configuré avec un jeu de données de configuration de caractérisation et avec un jeu de valeurs d'initialisation représentatif du programme banc et du processeur, et pour déterminer un jeu de coefficients de caractérisation en appliquant un algorithme de détermination du maximum de vraisemblance entre le jeu de temps d'exécution de référence et les jeux de temps d'exécution de caractérisation.
Le dispositif est enfin agencé pour retourner le jeu de données de configuration de caractérisation et le jeu de coefficients de caractérisation. Selon diverses variantes, le dispositif peut présenter une ou plusieurs des caractéristiques suivantes :
- le constructeur est agencé pour calculer les coefficients de caractérisation en déterminant, pour chaque jeu de temps d'exécution de caractérisation, une pluralité de vecteurs d'estimation dans lequel, pour chaque indice, la valeur est nulle ou vaut un si le temps d'exécution de caractérisation d'indice est le plus proche du temps d'exécution de référence pour cet indice parmi tous les temps d'exécution de caractérisation pour cet indice, ainsi qu'une variance pour chaque jeu de temps d'exécution de caractérisation à partir de la pluralité de vecteurs d'estimation et des différences entre les temps d'exécution de référence et les temps d'exécution de caractérisation d'indices identiques, et ensuite en calculant itérativement à partir d'une fenêtre glissante comprenant pour chaque itération et pour chaque jeu de temps d'exécution de caractérisation un nombre de temps d'exécutions égal au nombre d'éléments du jeu de temps d'exécution de référence et qui sont les plus récents :
une pluralité d'estimateurs pour l'itération courante, à partir d'une pluralité de lois normales pour chaque jeu de temps d'exécution de caractérisation qui ont en commun une variance tirée de celle de l'itération précédente, et dont la moyenne est tirée à chaque fois d'un temps d'exécution de caractérisation sélectionné par la fenêtre glissante de l'itération courante, lesquelles loi normales sont évaluées chacune au temps d'exécution du jeu de temps d'exécution de référence qui correspond à celui à partir duquel est déterminé la moyenne,
- une variance et un coefficient caractéristique pour chaque jeu de de temps d'exécution de caractérisation à partir de l'estimateur de l'itération courante, des différences entre les temps d'exécution de référence et les temps d'exécution de caractérisation d'indices identiques sélectionnés par la fenêtre glissante de l'itération courante, et le nombre d'éléments du jeu de temps d'exécution de référence,
- un nouveau temps d'exécution de caractérisation pour chaque jeu de temps d'exécution de caractérisation en appliquant une loi normale dont la variance est celle calculée pour chaque jeu de temps d'exécution de caractérisation pour l'itération courante et la moyenne est le temps d'exécution de caractérisation d'indice le plus élevé dans la fenêtre glissante, laquelle loi normale est évaluée au temps d'exécution du jeu de temps de référence d'indice le plus élevé dans la fenêtre glissante, et un nouveau temps d'exécution de référence à partir des nouveaux temps d'exécution de caractérisation pour chaque jeu de temps d'exécution de caractérisation et des coefficients caractéristiques pour chaque jeu de de temps d'exécution de caractérisation pour l'itération courante,
les itérations étant répétées jusqu'à ce qu'une condition portant sur le nombre d'itérations ou sur une différence entre les coefficients de caractérisation pour chaque jeu de de temps d'exécution de caractérisation d'itérations consécutives soit remplie, le jeu de coefficients de caractérisation étant défini à partir des coefficients de caractérisation de la dernière itération,
- le constructeur est agencé pour calculer les estimateurs selon la formule suivante :
où chaque z est un élément d'indice i dans l'estimateur z, N désigne la loi normale de moyenne m et de variance s, Mk désigne le temps d'exécution d'indice i dans le k-ième jeu de temps d'exécution de caractérisation, sig est la variance pour le k-ième jeu de temps d'exécution de caractérisation et Mo désigne le temps d'exécution d'indice i dans le jeu de temps d'exécution de référence, - le constructeur est agencé pour calculer les variances selon la formule suivante :
où z est l'élément d'indice i dans l'estimateur z pour le k-ième jeu de temps d'exécution de caractérisation, Mk désigne le temps d'exécution d'indice i dans le k-ième jeu de temps d'exécution de caractérisation, et Mo désigne le temps d'exécution d'indice i dans le jeu de temps d'exécution de référence,
- le constructeur est agencé pour calculer les coefficients de caractérisation selon la formule suivante :
où z est l'élément d'indice i dans l'estimateur z pour le k-ième jeu de temps d'exécution de caractérisation et T est le nombre d'éléments du jeu de temps d'exécution de référence Mo,
- le constructeur est agencé pour calculer les nouveaux temps d'exécution de caractérisation selon la formule suivante :
où N désigne la loi normale de moyenne m et de variance s, Mk désigne le temps d'exécution d'indice i dans le k-ième jeu de temps d'exécution de caractérisation, et sig est la variance pour le k-ième jeu de temps d'exécution de caractérisation, et
- le constructeur est agencé pour calculer les nouveaux temps d'exécution de référence selon la formule suivante :
où Mo désigne le temps d'exécution d'indice i dans le jeu de temps d'exécution de référence, Mk désigne le temps d'exécution d'indice i dans le k-ième jeu de temps d'exécution de caractérisation, et alph est le coefficient de caractérisation associé au k- ième jeu de temps d'exécution de caractérisation dans la j-ième itération.
L'invention concerne également un dispositif de calcul d'une base de temps d'exécution pire-cas d'un programme par un processeur comprenant une mémoire agencée pour recevoir des données de programme, des jeux de données de configuration de caractérisation et un jeu de coefficients de caractérisation obtenu par l'exécution du dispositif décrit plus haut, et un modélisateur agencé pour :
déterminer une pluralité de jeux de valeurs d'initialisation pour chaque jeu de données de configuration de caractérisation, le nombre de jeux de valeurs d'initialisation étant le même pour tous les jeu de données de configuration de caractérisation,
déterminer une pluralité de temps d'exécutions en exécutant le programme par le processeur configuré avec chaque jeu de données de configuration de caractérisation et avec à chaque fois la pluralité de jeux de valeurs d'initialisation correspondante, et
ajouter dans une base de temps d'exécution pire-cas une pluralité de temps d'exécution pire-cas, qui sont chacun égaux à la somme pour chaque les jeux de données de configuration de caractérisation du produit d'un des temps d'exécutions par le coefficient de caractérisation associé au jeu de données de configuration de caractérisation qui a permis d'obtenir ce temps d'exécution, de sorte que la base de temps d'exécution pire-cas comprend un nombre de temps d'exécution égale au nombre de jeux de valeurs d'initialisation pour chaque jeu de données de configuration de caractérisation. Selon diverses variantes, le dispositif peut présenter une ou plusieurs des caractéristiques suivantes :
- le modélisateur est en outre agencé pour extrapoler des temps d'exécution pire-cas, et
- le modélisateur est en outre agencé pour déterminer un temps d'exécution pire-cas avec une probabilité correspondante en appliquant un algorithme pWCET à la base de temps d'exécution pire-cas.
L'invention concerne également un procédé de caractérisation de temps d'exécution par un processeur , comprenant les opérations suivantes :
a) recevoir des données de programme banc, des jeux de données de configuration de caractérisation et des jeux de données de cas d'exécution ,
b) pour chaque jeu de données de cas d'exécution, déterminer un jeu de données de configuration pire-cas du processeur et un jeu de valeurs d'initialisation à partir d'un jeu de données de cas d'exécution , et déterminer un temps d'exécution de référence en exécutant le programme banc selon le jeu de données de cas d'exécution par le processeur configuré avec le jeu de données de configuration avec le jeu de valeurs d'initialisation, l'ensemble des temps d'exécution de référence formant un jeu de temps d'exécution de référence,
c) pour chaque jeu de données de configuration de caractérisation, déterminer un jeu de temps d'exécution de caractérisation, chaque jeu de temps d'exécution de caractérisation comprenant un nombre de temps d'exécution de caractérisation égal au nombre d'éléments du jeu de temps d'exécution de référence et chaque temps d'exécution de caractérisation étant déterminé en exécutant le programme banc par le processeur configuré avec un jeu de données de configuration de caractérisation et avec un jeu de valeurs d'initialisation représentatif du programme banc et du processeur,
d) déterminer un jeu de coefficients de caractérisation en appliquant un algorithme de détermination du maximum de vraisemblance entre le jeu de temps d'exécution de référence et les jeux de temps d'exécution de caractérisation , et
e) retourner le jeu de données de configuration de caractérisation et le jeu de coefficients de caractérisation. Selon diverses variantes, le procédé peut présenter une ou plusieurs des caractéristiques suivantes :
- l'opération d) comprend calculer les coefficients de caractérisation en déterminant, pour chaque jeu de temps d'exécution de caractérisation, une pluralité de vecteurs d'estimation dans lequel, pour chaque indice, la valeur est nulle ou vaut un si le temps d'exécution de caractérisation d'indice est le plus proche du temps d'exécution de référence pour cet indice parmi tous les temps d'exécution de caractérisation pour cet indice, ainsi qu'une variance pour chaque jeu de temps d'exécution de caractérisation à partir de la pluralité de vecteurs d'estimation et des différences entre les temps d'exécution de référence et les temps d'exécution de caractérisation d'indices identiques, et ensuite en calculant itérativement à partir d'une fenêtre glissante comprenant pour chaque itération et pour chaque jeu de temps d'exécution de caractérisation un nombre de temps d'exécutions égal au nombre d'éléments du jeu de temps d'exécution de référence et qui sont les plus récents :
une pluralité d'estimateurs pour l'itération courante, à partir d'une pluralité de lois normales pour chaque jeu de temps d'exécution de caractérisation qui ont en commun une variance tirée de celle de l'itération précédente, et dont la moyenne est tirée à chaque fois d'un temps d'exécution de caractérisation sélectionné par la fenêtre glissante de l'itération courante, lesquelles loi normales sont évaluées chacune au temps d'exécution du jeu de temps d'exécution de référence qui correspond à celui à partir duquel est déterminé la moyenne,
- une variance et un coefficient caractéristique pour chaque jeu de de temps d'exécution de caractérisation à partir de l'estimateur de l'itération courante, des différences entre les temps d'exécution de référence et les temps d'exécution de caractérisation d'indices identiques sélectionnés par la fenêtre glissante de l'itération courante, et le nombre d'éléments du jeu de temps d'exécution de référence,
- un nouveau temps d'exécution de caractérisation pour chaque jeu de temps d'exécution de caractérisation en appliquant une loi normale dont la variance est celle calculée pour chaque jeu de temps d'exécution de caractérisation pour l'itération courante et la moyenne est le temps d'exécution de caractérisation d'indice le plus élevé dans la fenêtre glissante, laquelle loi normale est évaluée au temps d'exécution du jeu de temps de référence d'indice le plus élevé dans la fenêtre glissante, et un nouveau temps d'exécution de référence à partir des nouveaux temps d'exécution de caractérisation pour chaque jeu de temps d'exécution de caractérisation et des coefficients caractéristiques pour chaque jeu de de temps d'exécution de caractérisation pour l'itération courante,
les itérations étant répétées jusqu'à ce qu'une condition portant sur le nombre d'itérations ou sur une différence entre les coefficients de caractérisation pour chaque jeu de de temps d'exécution de caractérisation d'itérations consécutives soit remplie, le jeu de coefficients de caractérisation étant défini à partir des coefficients de caractérisation de la dernière itération,
- l'opération d) comprend calculer les estimateurs selon la formule suivante :
où chaque z est un élément d'indice i dans l'estimateur z, N désigne la loi normale de moyenne m et de variance s, Mk désigne le temps d'exécution d'indice i dans le k-ième jeu de temps d'exécution de caractérisation, sig est la variance pour le k-ième jeu de temps d'exécution de caractérisation et Mo désigne le temps d'exécution d'indice i dans le jeu de temps d'exécution de référence,
- l'opération d) comprend calculer les variances selon la formule suivante :
où z est l'élément d'indice i dans l'estimateur z pour le k-ième jeu de temps d'exécution de caractérisation, Mk désigne le temps d'exécution d'indice i dans le k-ième jeu de temps d'exécution de caractérisation, et Mo désigne le temps d'exécution d'indice i dans le jeu de temps d'exécution de référence,
- l'opération d) comprend calculer les coefficients de caractérisation selon la formule suivante :
où z est l'élément d'indice i dans l'estimateur z pour le k-ième jeu de temps d'exécution de caractérisation et T est le nombre d'éléments du jeu de temps d'exécution de référence Mo,
- l'opération d) comprend calculer les nouveaux temps d'exécution de caractérisation selon la formule suivante :
où N désigne la loi normale de moyenne m et de variance s, Mk désigne le temps d'exécution d'indice i dans le k-ième jeu de temps d'exécution de caractérisation, et sig est la variance pour le k-ième jeu de temps d'exécution de caractérisation, et
- l'opération d) comprend calculer les nouveaux temps d'exécution de référence selon la formule suivante :
où Mo désigne le temps d'exécution d'indice i dans le jeu de temps d'exécution de référence, Mk désigne le temps d'exécution d'indice i dans le k-ième jeu de temps d'exécution de caractérisation, et alph est le coefficient de caractérisation associé au k- ième jeu de temps d'exécution de caractérisation dans la j-ième itération.
L'invention concerne également un procédé de calcul d'une base de temps d'exécution pire-cas d'un programme par un processeur comprenant a) recevoir des données de programme, des jeux de données de configuration de caractérisation et un jeu de coefficients de caractérisation obtenu par l'exécution du dispositif ou du procédé décrits plus haut,
b) déterminer une pluralité de jeux de valeurs d'initialisation pour chaque jeu de données de configuration de caractérisation, le nombre de jeux de valeurs d'initialisation étant le même pour tous les jeu de données de configuration de caractérisation,
c) déterminer une pluralité de temps d'exécutions en exécutant le programme par le processeur configuré avec chaque jeu de données de configuration de caractérisation et avec à chaque fois la pluralité de jeux de valeurs d'initialisation correspondante, et
d) ajouter dans une base de temps d'exécution pire-cas une pluralité de temps d'exécution pire-cas, qui sont chacun égaux à la somme pour chaque les jeux de données de configuration de caractérisation du produit d'un des temps d'exécutions par le coefficient de caractérisation associé au jeu de données de configuration de caractérisation qui a permis d'obtenir ce temps d'exécution, de sorte que la base de temps d'exécution pire-cas comprend un nombre de temps d'exécution égale au nombre de jeux de valeurs d'initialisation pour chaque jeu de données de configuration de caractérisation.
Selon diverses variantes, le procédé peut présenter une ou plusieurs des caractéristiques suivantes :
- e) extrapoler des temps d'exécution pire-cas, et - el) déterminer un temps d'exécution pire-cas avec une probabilité correspondante en appliquant un algorithme pWCET à la base de temps d'exécution pire-cas.
D'autres caractéristiques et avantages de l'invention apparaîtront mieux à la lecture de la description qui suit, tirée d'exemples donnés à titre illustratif et non limitatif, tirés des dessins sur lesquels :
- la figure 1 représente un diagramme schématique d'un dispositif selon invention,
- la figure 2 représente un exemple de mise en œuvre d'une fonction par un élément de la figure 1 ,
- la figure 3 représente un exemple de mise en œuvre d'une fonction de la figure 2,
- la figure 4 représente un exemple de mise en œuvre d'une fonction de la figure 2,
- la figure 5 représente un exemple de mise en œuvre d'une fonction de la figure 2,
- la figure 6 représente un exemple de mise en œuvre d'une fonction par un élément de la figure 1 , et
- la figure 7 représente un exemple de mise en œuvre d'une fonction de la figure 6.
Les dessins et la description ci-après contiennent, pour l'essentiel, des éléments de caractère certain. Ils pourront donc non seulement servir à mieux faire comprendre la présente invention, mais aussi contribuer à sa définition, le cas échéant.
La présente description est de nature à faire intervenir des éléments susceptibles de protection par le droit d'auteur et/ou le copyright. Le titulaire des droits n'a pas d'objection à la reproduction à l'identique par quiconque du présent document de brevet ou de sa description, telle qu'elle apparaît dans les dossiers officiels. Pour le reste, il réserve intégralement ses droits.
En outre, la description détaillée est augmentée de l'annexe A, qui donne la formulation de certaines formules mathématiques mises en œuvre dans le cadre de l'invention. Cette Annexe est mise à part dans un but de clarification, et pour faciliter les renvois. Elle est partie intégrante de la description, et pourra donc non seulement servir à mieux faire comprendre la présente invention, mais aussi contribuer à sa définition, le cas échéant. La figure 1 représente un dispositif 2 selon l'invention dans son environnement. Le dispositif 2 comprend un constructeur 4, un modélisateur 6 et une mémoire 8.
Dans le cadre de l'invention, la mémoire 8 peut être tout type de stockage de données propre à recevoir des données numériques : disque dur, disque dur à mémoire flash (SSD en anglais), mémoire flash sous toute forme, mémoire vive, disque magnétique, stockage distribué localement ou dans le cloud, etc. Les données calculées par le dispositif peuvent être stockées sur tout type de mémoire similaire à la mémoire 8, ou sur celle-ci. Ces données peuvent être effacées après que le dispositif ait effectué ses tâches ou conservées.
Les données stockées dans la mémoire 8 sont des données de programme à tester, des jeux de facteurs de processeur et des n-uplets représentant des temps d'exécution d'un programme donné par un processeur configuré avec un jeu de facteurs donné. Dans l'exemple décrit ici, ces données sont calculées par le modélisateur 6. En variante, elles pourraient être obtenues différemment. Les données stockées dans la mémoire 8 pourraient également être agencées sous une autre forme.
Le constructeur 4 et le modélisateur 6 sont des éléments accédant directement ou indirectement à la mémoire 8. Ils peuvent être réalisés sous la forme d'un code informatique approprié exécuté sur un ou plusieurs processeurs. Par processeurs, il doit être compris tout processeur adapté aux calculs décrits plus bas. Un tel processeur peut être réalisé de toute manière connue, sous la forme d'un microprocesseur pour ordinateur personnel, d'une puce dédiée de type FPGA ou SoC (« System on chip » en anglais), d'une ressource de calcul sur une grille, d'un microcontrôleur, ou de toute autre forme propre à fournir la puissance de calcul nécessaire à la réalisation décrite plus bas. Un ou plusieurs de ces éléments peuvent également être réalisés sous la forme de circuits électroniques spécialisés tel un ASIC. Une combinaison de processeur et de circuits électroniques peut également être envisagée. Le constructeur 4 a pour fonction la détermination d'un jeu de coefficients stocké dans un vecteur alph[]. Ce jeu de coefficients est déterminé sur la base d'un programme banc (« benchmark program » en anglais) pour un processeur que l'on cherche caractériser, ainsi que pour un jeu de facteurs de processeur choisi pour le processeur que l'on cherche caractériser.
En effet, un processeur peut être caractérisé par certains facteurs qui vont affecter son fonctionnement. Par exemple, ces facteurs peuvent être l'état d'activation de l'un ou de plusieurs des cœurs du processeur et/ou leur fréquence de fonctionnement, l'état de fonctionnement d'une ou plusieurs mémoires vives bas niveau, l'état de fonctionnement de l'un ou de plusieurs des bus de communication au sein du processeur, l'état de fonctionnement de l'une ou de plusieurs des mémoires tampons du processeur, l'état d'activation de fonction spécifiques de traitement de données, etc.
Dans ce qui suit, le constructeur 4 va déterminer un jeu de données de temps d'exécution pire cas pour le programme banc pour le processeur donné dans une configuration pire cas, ainsi que pour chacun des jeux de facteurs de processeur. Ensuite, le jeu de coefficients sera calculé pour représenter une correspondance entre les jeux de données de temps d'exécution associés à chacun des jeux de facteurs de processeur et le jeu de temps d'exécution pire cas.
Le modélisateur 6 a pour rôle Γ exploitation du jeu de coefficients. Ainsi, le modemisateur 6 reçoit des données de simulation 10 comprenant des données de programme à qualifier, le programme à qualifier étant considéré comme suffisamment similaire au programme banc. Les données de simulations 10 sont utilisées avec les jeux de facteurs de processeur pour déterminer des jeux de données de temps d'exécution du programme à qualifier pour chacun des jeux de facteurs de processeur, puis le jeu de coefficients est utilisé pour générer un jeu de données de temps d'exécution pire cas pour le programme à qualifier.
Ce jeu de données de temps d'exécution pire cas peut ensuite être étendu de manière synthétique afin de générer un grand nombre de temps d'exécution qui sont caractéristiques de l'exécution du programme à qualifier par le processeur donné en conditions pire cas. Ces données étendues sont stockées dans des données pire cas 12 qui peuvent être utilisées conformément à ce qui a été décrit dans la demande de brevet français FR 15 51828 (ou par une autre manière) pour déterminer un temps d'exécution pire cas par le processeur donné pour le programme à qualifier.
Le temps pour obtenir le jeu de données de temps d'exécution pire cas et son extension est bien plus court que le temps qui serait nécessaire à l'acquisition directe de temps d'exécution pour ce même programme en l'exécutant sur le processeur donné pour l'ensemble des événements.
Ainsi, le modélisateur 6 permet d'obtenir un jeu de données de temps d'exécution pire cas comprenant un très grand nombre de données de manière bien plus rapide que ce qui était possible précédemment. Cela est obtenu en réalisant la quantité de calculs la plus intensive une seule fois pour calculer le jeu de coefficients, et réutilisant ceux-ci pour permettre de qualifier tous les programmes ultérieurs, dès lors qu'ils sont suffisamment semblables au programme banc.
Selon les variantes, le dispositif 2 peut comprendre le constructeur 4 et le modélisateur 6 ensemble, ou l'un seulement d'entre eux. En particulier, le modélisateur 6 pourrait recevoir, en plus des données de simulation 10, des données contenant le jeu de coefficients ainsi que les jeux de facteurs de processeur.
En variante, le dispositif de l'invention peut être utilisé dans d'autres applications que la détermination de temps « pire-cas » d'une tâche par un processeur, dès lors qu'il s'agit d'étudier la prise de valeurs extrêmes d'un paramètre physique. Tout comme les autres éléments, le constructeur 4 et le modélisateur 6 peuvent être réalisés de très nombreuses manières et être, par exemple, codé sous la forme d'un programme informatique.
La figure 2 représente un exemple d'une fonction mise en œuvre par le constructeur 4 pour calculer le jeu de coefficients. Dans une opération 200, le constructeur 4 exécute une fonction Trnl() pour calculer le jeu de données de temps d'exécution pire cas pour le programme banc pour le processeur donné dans une configuration pire cas. La figure 3 représente un exemple de mise en œuvre de la fonction Trnl().
Dans une opération 300, un indice i est initialisé à zéro, et le programme banc B et le processeur P sont reçus.
Dans une opération 310, une fonction Cas() recevant le programme banc B est exécutée afin de déterminer tous les cas d'exécution possibles pour le programme banc B. Ces cas d'exécution possibles sont stockés dans un vecteur J. Pour cela, le programme banc et découper de manière automatique ou manuelle en une pluralité de blocs d'appel relié entre eux par un graphe de séquencement du programme banc B, et les cas d'exécution sont générés en tenant compte des diverses possibilités matérielles d'exécution de ces blocs d'appel, sur l'ensemble des combinaisons possibles de blocs d'appel au sein du graphe de séquencement du programme banc B. En variante, le vecteur J peut être reçu comme un paramètre, par exemple par l'utilisateur.
Une boucle est alors lancée à partir d'une opération 320 dans laquelle l'ensemble des cas d'exécutions parcouru et exécuté par le processeur afin d'en tirer un temps d'exécution pire cas. Ainsi, dans l'opération 320, le vecteur J est dépilé dans une variable S, puis le jeu de facteurs de processeur F est déterminé dans une opération 330, le processeur est initialisé dans une opération 340, et un vecteur de valeurs d'initialisation V est généré par une fonction Rand() qui reçoit la variable S comme argument dans une opération 350. Dans l'exemple décrit ici, la fonction Rand() génère le vecteur de valeurs d'initialisation V de manière aléatoire En variante, la fonction Rand() pourrait définir le vecteur de valeurs d'initialisation V en le choisissant parmi un groupe de vecteurs qui sont représentatifs d'un point de vue statistique par rapport au cas d'exécution S sur le processeur P.
Dans l'opération 330, une fonction Wc() recevant le processeur P et la variable S comme arguments est exécutée afin de déterminer un jeu de facteurs de processeur F correspondant au fonctionnement pire cas pour le processeur P dans le cas d'exécution S. Par exemple, la fonction Wc() va générer un jeu de facteurs de processeur dans lequel un seul des cœurs est activé, avec une fréquence de fonctionnement minimale, en désactivant les mémoires tampons, et en prévoyant un dysfonctionnement du bus de communication sur le processeur. En variante, le jeu de facteurs de processeur F peut être reçu comme paramètre, par exemple par l'utilisateur.
Une fonction Init() est alors exécutée dans l'opération 340 avec le processeur P et le jeu de facteurs de processeur F comme arguments. Cette fonction accède au processeur P et le configure conformément au jeu de facteurs de processeur F. L'opération 350 peut être réalisé après l'opération 340, avant celle-ci ou en parallèle.
Le temps d'exécution pire cas correspondant à la variable S est déterminé en exécutant une fonction Ex() dans une opération 360. La fonction Ex() exécute le cas d'exécution défini par la variable S avec le vecteur de valeurs d'initialisation V sur le processeur P initialisé à l'opération 340.
Le temps d'exécution résultant est stocké dans le jeu de données de temps d'exécution pire cas M0[i], puis l'indice i est incrémenté dans une opération 370 et la boucle reprend avec l'opération 340. Lorsque tous les cas d'exécution ont été parcourus, la fonction Trnl() se termine dans une opération 399 avec le renvoi du jeu de données de temps d'exécution pire cas MO.
Le constructeur 4 exécute ensuite une fonction Trn2() dans une opération 210 dans laquelle il détermine une pluralité de jeux de données de temps d'exécution respectif à des jeux de facteurs de processeur choisis dans un ensemble de jeux de facteurs de processeur. Comment on l'a décrit plus haut, l'ensemble de jeux de facteurs de processeur est choisi de manière à caractériser le comportement pire cas du processeur P, à la manière des vecteurs propres d'une matrice. Typiquement, chaque jeu de facteurs de processeur est défini en activant et/ou optimisant un ou plusieurs facteurs du processeur P, et en définissant tous les autres facteurs à leur valeur pire cas.
La figure 4 représente un exemple de mise en œuvre de la fonction Trn2(). Dans une opération 400, un indice i est initialisé à zéro, et l'ensemble de jeux de facteurs de processeur F, le programme banc B, le processeur P sont reçus, ainsi que le jeu de données de temps d'exécution pire cas MO. Il convient de noter que l'ensemble de jeux de facteurs de processeur F reçus dans l'opération 400 est distinct de celui déterminé dans l'opération 330. Ici, chaque jeu de facteurs de l'ensemble de jeux de facteurs de processeur F représente une configuration que la fonction vise à qualifier.
Dans une opération 410, une variable T est créée et reçoit le nombre de temps d'exécution contenus dans le jeu de données de temps d'exécution pire cas MO. De manière similaire, dans une opération 420, une variable K est créée et reçoit le nombre de jeux de facteurs de processeur contenus dans l'ensemble de jeux de facteurs de processeur F.
Une boucle est alors lancée dans laquelle un ensemble de jeux de données de temps d'exécution Ml à MK va être généré pour chaque jeu de facteurs de processeur, chaque jeu de données de temps d'exécution Ml à MK recevant un nombre de temps d'exécution égal à la variable T.
L'indice k du jeu de facteurs de processeur pour lequel un temps d'exécution doit être déterminé pour une instance donnée de la boucle est déterminé dans une opération 430 en calculant l'indice i modulo la variable K.
L'indice j du temps d'exécution dans le jeu de données de temps d'exécution Mk est déterminé pour une instance donnée de la boucle est déterminé dans une opération 440 en calculant la partie entière de la division de l'indice i par la variable T.
Les opérations 430 et 440 ont pour conséquence que les jeux de données de temps d'exécution Mk sont déterminés de manière croissante, un temps d'exécution à la fois. Cela peut être réalisé dans un autre ordre, dès lors qu'un aléa est préservé afin de ne pas biaiser la construction des jeux de données de temps d'exécution Mk.
Ensuite, le processeur P est initialisé avec le jeu de facteurs de processeur d'indice k dans l'ensemble de jeux de facteurs de processeur dans une opération 450 similaire à l'opération 340, puis un vecteur de valeurs d'initialisation V est généré en appliquant une fonction Rand2() au programme banc B dans une opération 460 de manière similaire à l'opération 350. Dans l'exemple décrit ici, la fonction Rand2() génère le vecteur de valeurs d'initialisation V de manière aléatoire En variante, la fonction Rand2() pourrait définir le vecteur de valeurs d'initialisation V en le choisissant parmi un groupe de vecteurs qui sont représentatifs d'un point de vue statistique par rapport au cas d'exécution S sur le processeur P.
Enfin, le temps d'exécution pire cas correspondant au vecteur de valeurs d'initialisation V est déterminé en exécutant une fonction Ex() dans une opération 470. La fonction Ex() exécute le cas d'exécution défini par le vecteur de valeurs d'initialisation V pour le programme banc B sur le processeur P initialisé à l'opération 450.
Le temps d'exécution résultant est stocké dans le jeu de données de temps d'exécution Mk[j], puis l'indice i est testé dans une opération 480 afin de déterminer si tous les jeux de données de temps exécution Mk ont été calculés.
Si ce n'est pas le cas, alors l'indice i est incrémenté dans une opération 480 et la boucle reprend avec l'opération 430. Sinon, la fonction Trn2() se termine dans une opération 499 avec le renvoi de l'ensemble de jeux de données de temps d'exécution Ml à MK.
Le constructeur 4 exécute ensuite une fonction Fit() dans une opération 220 dans laquelle il détermine un jeu de coefficients alph[] qui caractérise la correspondance entre chacun des jeux de données de temps d'exécution Ml à MK avec le jeu de données de temps exécution pire cas MO.
Cela est réalisé en appliquant un modèle bayésien (« Bayesian Model Averaging » en anglais). Selon ce modèle, la fonction de distribution de probabilité d'une prédiction, sur la base d'une pluralité de modèles Ml à MK pour expliquer un modèle MO peut être peut-être écrite conformément à la formule [10] de l'annexe A. Les travaux de la Demanderesse ont révélé qu'en corrigeant le biais des jeux de données de temps d'exécution Ml à MK, ceux-ci peuvent être réécrits sous la forme de prédicteurs fl à fK, ce qui permet de définir une fonction de distribution de probabilité conditionnelle sur chaque prédicteur fk, et de réécrire la formule [10] conformément à la formule [20] de l'annexe A. Dans cette formule, chaque fonction de distribution de probabilité conditionnelle sur un prédicteur fk peut alors être approchée au moyen d'une loi normale centrée sur une fonction linéaire du prédicteur fk. La détermination de l'ensemble des lois normales sur la base des prédicteurs fk permet alors de déterminer tous les coefficients du vecteur alph[]. Pour cela, la Demanderesse utilise la fonction de vraisemblance dont elle maximise le logarithme conformément à l'algorithme EM (« The EM algorithm and extensions » par Geoffrey J. McLachlan, et Thriyambakam Krishnan, 1997) qui est une extension de l'article « Maximum Likelihood from Incomplète Data via the EM Algorithm » de Dempster, Laird et Rubin dans Journal of the Royal Statistical Society. Séries B (Methodological), Vol. 39, No. 1. (1977), pp. 1- 38. Cela est réalisé en utilisant la formule [30] de l'annexe A.
La Figure 5 représente un exemple de mise en œuvre de la fonction permettant de déterminer le vecteur alph[] pour les jeux de données de temps d'exécution Ml à MK par rapport au jeu de données de temps d'exécution MO.
Dans une opération 500, les jeux de données de temps d'exécution MO à MK sont reçues, ainsi que le nombre T de données dans chaque jeu de données de temps d'exécution, et un indice j est initialisé à 1.
Dans une opération 510, l'algorithme est initialisé en calculant un estimateur z(0) et une vecteur de variance sig(0) au moyen d'une fonction Min(). La fonction Min() reçoit les jeux de données MO à MK, et, pour chaque temps d'exécution de chaque jeu Ml à MK, définit une valeur qu'elle stocke dans z(0) qui vaut 1 si un temps d'exécution d'indice donné est le plus proche parmi tous les temps d'exécution de même indice du temps d'exécution ayant ce même indice dans MO. Dit autrement, si les jeux d'exécutions sont indiciés par la lettre i, alors z(0)(r,i) vaut 1 si Mr(i) est le plus proche de M0(i) parmi tous les Mk(i). Tous les autres z(0)(k,i) sont mis à 0. Ensuite, le vecteur de variance sig(0) est calculé pour chaque k selon la formule [40] de l'annexe A, avec j = 0. Une boucle est alors lancée dans laquelle l'estimateur z(j), le vecteur de variance sig(j) et le vecteur de poids alph(j) sont évalués séquentiellement, et les jeux de données sont étendus en utilisant une fenêtre glissante.
La boucle commence la mise à jour de l'estimateur z(j) est mis à jour dans une opération 530. Pour cela, chaque z(j)(k,i) est calculé à partir de la formule [50] de l'annexe A, où N(X,Y)(z) désigne la loi normale de moyenne X, de variance Y, calculée en z. L'indice i est compris entre j et T+j-1, et l'indice k est compris entre 1 et K. Le vecteur z(j) contient donc T*K valeurs. Le vecteur sig(j) est alors évalué dans une opération 530 en appliquant la formule [40] de l'annexe A, et le vecteur de poids alph(j) est évalué dans une opération 540 en appliquant la formule [60] de l'annexe A.
Les vecteurs sig(j) et alph(j) permettent de définir K lois normales déterminées sur une fenêtre d'indice i compris entre j et T+j-1 pour chacun des jeux de données de temps d'exécution Mk pour k compris entre 1 et K.
Enfin, de nouveaux temps d'exécution sont déterminés à partir de ces estimations dans une opération 550. Pour cela, une fonction M() est exécutée, qui calcule dans un premier temps un nouveau temps d'exécution Mk(T+j) pour chaque k compris entre 1 et K en appliquant la formule [70] de l'annexe A, c'est-à-dire en appliquant la loi normale dont les paramètres viennent d'être évalués pour la fenêtre de temps d'exécution d'indice k dont les valeurs sont celles associées aux indices compris entre j-1 et T+j-1, avec comme moyenne le dernier temps d'exécution de cette fenêtre (c'est-à-dire Mk(T+j-l)), comme variance la valeur d'indice k du vecteur sig(j), évaluée au point M0(T+j-l). Une fois que la fenêtre a été étendue pour tous les k entre 1 et K, le jeu de données de temps d'exécution MO est également étendue conformément à la formule [80] de l'annexe A. Un test est alors réalisé dans une opération 560 pour déterminer si le vecteur alph(j) est suffisamment proche du vecteur alph(j-l), ce qui permet de déterminer que l'algorithme a convergé. Si ce n'est pas le cas, alors j est incrémenté dans une opération 570. Sinon, la fonction Fit() se termine alors en renvoyant le jeu de coefficients alph[j] dans une opération 599.
Dans l'exemple de la Figure 5, la longueur de la fenêtre glissante utilisée est égale à T, c'est-à-dire le nombre d'éléments de MO. Cependant, cette longueur représente un maximum et pourrait être inférieur. Par exemple, la longueur de la fenêtre glissante pourrait être choisie à partir de critères tels que le Continous Rank Probability Score (CRPS) ou le Root Mean Square Error (RMSE). Dans ce cas, les opérations 510, 530 et 550 pourront être adaptées à une longueur plus petite. La Figure 6 représente un exemple de mise en œuvre d'une fonction de calcul du temps de calcul pire cas pour un programme TP sur la base de la caractérisation qui vient d'être faite. En effet, le modèle de comportement pire cas MO du processeur P ayant été caractérisé au moyen des jeux de facteurs F[l] à F[K] et des poids alph[l] à alph[k] correspondants, il devient possible de caractériser un nouveau programme TP différent du programme banc B en testant le nouveau programme TP un nombre R de fois avec les jeux de facteurs F[l] à F[K], tout en ayant R très inférieur aux nombre d'exécutions du modèle MO du programme banc originel. Les travaux de la Demanderesse ont démontré qu'un nombre T = 1000 ou 10 000 et un nombre R = 100 d'exécutions suffisent pour obtenir des résultats satisfaisants. Cela signifie que l'invention permet de réduire par un ordre de 100 le nombre d'exécutions nécessaires de programme, par rapport aux 100 000 exécutions de l'art antérieur.
Ainsi, dans une opération 600, le modèle de temps d'exécution pire-cas pour le programme TP est déterminé en exécutant une fonction Use() qui reçoit le programme TP, le vecteur de poids alph[] et les jeux de facteurs F[l] à F[K] comme arguments. La Figure 7 représente un exemple de mise en œuvre de la fonction Use(). Dans une opération 700, un indice i est initialisé à 0, et les jeux de facteurs F, le nouveau programme TP, le processeur P et le nombre d'exécutions R sont reçus. Dans une opération 705, K est déterminé comme le nombre de jeux de facteurs F. Une boucle est alors exécutée pour réaliser R exécutions du nouveau programme TP sur le processeur P, initialisé selon chacun des jeux de facteurs F.
Pour cela, un indice k est calculé dans une opération 710 comme le reste de l'indice i modulo K, et indique quel jeu de facteur va être utilisé. Ensuite, ou parallèlement, un indice j est défini dans une opération 715 comme la partie entière de l'indice i divisé par K. Cela indiquera le rang du temps d'exécution déterminé. Dans une opération 720, la fonction Rand() est exécutée avec le nouveau programme TP pour générer un vecteur de valeurs d'initialisation V, comme pour les opérations 350 et 460. Enfin, le processeur P est initialisé dans une opération 725 avec le jeu de facteurs F[k] de manière identique aux opérations 340 et 450, et dans une opération 730 le programme TP est exécuté sur le processeur P initialisé avec le vecteur de valeurs d'initialisation V et le temps d'exécution correspondant est stocké dans le vecteur Mk[] à l'indice j. Enfin, un test d'une opération 735 détermine si i est strictement inférieur à R. Si c'est le cas, alors il est incrémenté dans une opération 740. Sinon, alors le nouveau programme TP a été caractérisé et le modèle pire cas ΜΤΡ0 est calculé dans des opérations 745 à 775.
Dans l'opération 745, l'indice j est réinitialisé à 0. Une double boucle est alors lancée dans laquelle chaque contribution d'indice j tirée de chaque jeu de facteurs est regroupée pour former un temps d'exécution pire cas d'indice j pour le nouveau programme TP. Pour cela, l'indice k est initialisé à 0 dans l'opération 750, et tous les jeux de facteurs sont traversés pour l'indice j donné en ajoutant à MTP0[j] la valeur Mk[j] multipliée par alph[k] dans une opération 755. Ainsi, MTP0[j] reçoit progressivement les contributions Mk[j] de chaque jeu de facteurs, un test dans l'opération 760 détermine si tous les jeux de facteurs ont été parcourus ou pas. Si ce n'est pas le cas, alors l'indice k est incrémenté dans l'opération 765 et la boucle en k reprend avec l'opération 755. Si c'est le cas, alors un test dans l'opération 770 détermine si toutes les lignes de MTP0[] ont été remplies. Si ce n'est pas le cas, alors l'indice j est incrémenté dans l'opération 775 et la boucle en i reprend avec l'opération 750. Si c'est le cas, alors la fonction se termine en 799. Ensuite, une fonction Extr() est exécutée dans une opération 610 sur le jeu de temps d'exécution pire cas MTPO. La fonction Extr() extrapole des données supplémentaires afin de compléter le jeu de temps d'exécution pire cas MTPO. Pour cela, elle applique les lois normales de chaque jeu de facteurs F[l] à F[K] en fenêtre glissante, comme cela a été fait avec l'opération 550, sauf que la variance sig(k) est fixée pour chaque jeu de facteurs.
Enfin, dans une opération 620, une fonction pWCET() calcul le temps d'exécution pire cas avec une probabilité correspondante avec le résultat de l'opération 630. Avantageusement, cette fonction peut être réalisée conformément aux enseignements de la demande de brevet français FR 15 51828 ou de toute autre manière adaptée.
L'invention permet donc d'obtenir des résultats permettant de déterminer les temps d'exécutions pire-cas d'un programme par un processeur à partir d'un nombre d'exécutions nettement inférieur à ce qui était connu précédemment (de l'ordre de 1000 exécutions contre plus de 100 000 avant). Cela permet donc de modifier avec plus de sûreté les programmes, puisque la question de la validation de ces derniers par les processeurs ne constitue plus un problème critique en termes de temps d'exécution. De plus, cela permet également de réaliser des bancs de comparaison de processeurs pour l'exécution d'un programme donné. En effet, il devient rapidement possible de comparer les processeurs entre eux.

Claims

Revendications
1. Dispositif informatique de caractérisation de temps d' exécution par un processeur (P), comprenant une mémoire (8) agencée pour recevoir des données de programme banc (B), des jeux de données de configuration de caractérisation (F[k]) et des jeux de données de cas d'exécution (S), et
un constructeur (4) agencé, pour chaque jeu de données de cas d'exécution (S), pour déterminer un jeu de données de configuration pire-cas du processeur (F) et un jeu de valeurs d'initialisation (V) à partir d'un jeu de données de cas d'exécution (S), et déterminer un temps d'exécution de référence (M0[i]) en exécutant le programme banc (B) selon le jeu de données de cas d'exécution (S) par le processeur (P) configuré avec le jeu de données de configuration (F) avec le jeu de valeurs d'initialisation (V), l'ensemble des temps d'exécution de référence formant un jeu de temps d'exécution de référence (MO),
le constructeur (4) étant en outre agencé, pour chaque jeu de données de configuration de caractérisation (F[k]), pour déterminer un jeu (Mk) de temps d'exécution de caractérisation (Mk[j]), chaque jeu (Mk) de temps d'exécution de caractérisation (Mk[j]) comprenant un nombre de temps d'exécution de caractérisation (Mk[j]) égal au nombre (T) d'éléments du jeu de temps d'exécution de référence (MO) et chaque temps d'exécution de caractérisation (Mk[j]) étant déterminé en exécutant le programme banc (B) par le processeur (P) configuré avec un jeu de données de configuration de caractérisation (F[k]) et avec un jeu de valeurs d'initialisation (V) représentatif du programme banc (B) et du processeur (P),
le constructeur (4) étant en outre agencé pour déterminer un jeu de coefficients de caractérisation (alph[k]) en appliquant un algorithme de détermination du maximum de vraisemblance entre le jeu de temps d'exécution de référence (MO) et les jeux de temps d'exécution de caractérisation (M[k]),
le dispositif étant agencé pour retourner le jeu de données de configuration de caractérisation (F) et le jeu de coefficients de caractérisation (alph[k]).
2. Dispositif selon la revendication 1, dans lequel le constructeur (4) est agencé pour calculer les coefficients de caractérisation (alph[k]) en déterminant, pour chaque jeu (Mk) de temps d'exécution de caractérisation (Mk[j]), une pluralité d'estimateurs (z(0)(k)) dans lequel, pour chaque indice (j), la valeur est nulle ou vaut un si le temps d'exécution de caractérisation (Mk[j]) d'indice (j) est le plus proche du temps d'exécution de référence (M0[j]) pour cet indice (j) parmi tous les temps d'exécution de caractérisation (Ml [j] ...MK[j]) pour cet indice (j), ainsi qu'une variance
(sig(0)(k)) pour chaque jeu de temps d'exécution de caractérisation (Mk) à partir de la pluralité de vecteurs d'estimation (z(0)(k)) et des différences entre les temps d'exécution de référence (M0[i]) et les temps d'exécution de caractérisation (Mk[i]) d'indices identiques,
et ensuite en calculant itérativement à partir d'une fenêtre glissante comprenant pour chaque itération et pour chaque jeu (Mk) de temps d'exécution de caractérisation (Mk[j]) un nombre de temps d'exécutions égal au nombre (T) d'éléments du jeu de temps d'exécution de référence (MO) et qui sont les plus récents :
une pluralité de vecteurs d'estimation (z(k)(j+l)) pour l'itération courante, à partir d'une pluralité de lois normales pour chaque jeu de temps d'exécution de caractérisation (Mk) qui ont en commun une variance tirée de celle de l'itération précédente (sig(k)(j-l)), et dont la moyenne est tirée à chaque fois d'un temps d'exécution de caractérisation (Mk[i]) sélectionné par la fenêtre glissante de l'itération courante, lesquelles loi normales sont évaluées chacune au temps d'exécution du jeu de temps d'exécution de référence (M0[i]) qui correspond à celui à partir duquel est déterminé la moyenne,
- une variance (sig(j)(k)) et un coefficient caractéristique (alph(j)(k)) pour chaque jeu de (Mk) de temps d'exécution de caractérisation (Mk[j]) à partir de l'estimateur (z(j)(k)) de l'itération courante, des différences entre les temps d'exécution de référence (M0[i]) et les temps d'exécution de caractérisation
(Mk[i]) d'indices identiques sélectionnés par la fenêtre glissante de l'itération courante, et le nombre (T) d'éléments du jeu de temps d'exécution de référence (MO),
- un nouveau temps d'exécution de caractérisation (Mk[T+j]) pour chaque jeu de temps d'exécution de caractérisation (Mk) en appliquant une loi normale dont la variance est celle calculée pour chaque jeu de temps d'exécution de caractérisation pour l'itération courante (sig(j)(k)) et la moyenne est le temps d'exécution de caractérisation (Mk[T+j-l]) d'indice le plus élevé dans la fenêtre glissante, laquelle loi normale est évaluée au temps d'exécution du jeu de temps de référence (M0[T+j-l]) d'indice le plus élevé dans la fenêtre glissante, et un nouveau temps d'exécution de référence (M0[T+j]) à partir des nouveaux temps d'exécution de caractérisation (Mk[T+j]) pour chaque jeu de temps d'exécution de caractérisation (Mk) et des coefficients caractéristiques (alph(j)(k)) pour chaque jeu de (Mk) de temps d'exécution de caractérisation (Mk[j]) pour l'itération courante,
les itérations étant répétées jusqu'à ce qu'une condition portant sur le nombre d'itérations ou sur une différence entre les coefficients de caractérisation (alph(j)(k)) pour chaque jeu de (Mk) de temps d'exécution de caractérisation d'itérations consécutives soit remplie, le jeu de coefficients de caractérisation (alph[k]) étant défini à partir des coefficients de caractérisation (alph(j)(k)) de la dernière itération.
3. Dispositif selon la revendication 2, dans lequel le constructeur (4) est agencé pour calculer les estimateurs (z(j)(k)) selon la formule suivante :
où chaque z(j)(k,i) est un élément d'indice i dans l'estimateur z(j)(k), N(m,s) désigne la loi normale de moyenne m et de variance s, Mk(i) désigne le temps d'exécution d'indice i dans le k-ième jeu de temps d'exécution de caractérisation (Mk), sig(j-l)(k) est la variance pour le k-ième jeu de temps d'exécution de caractérisation (Mk) et M0(i) désigne le temps d'exécution d'indice i dans le jeu de temps d'exécution de référence.
4. Dispositif selon la revendication 2 ou 3, dans lequel le constructeur (4) est agencé pour calculer les variances (sig(j)(k)) selon la formule suivante :
où z(j)(k,i) est l'élément d'indice i dans l'estimateur z(j)(k) pour le k-ième jeu de temps d'exécution de caractérisation, Mk(i) désigne le temps d'exécution d'indice i dans le k-ième jeu de temps d'exécution de caractérisation (Mk), et M0(i) désigne le temps d'exécution d'indice i dans le jeu de temps d'exécution de référence.
Dispositif selon l'une des revendications 2 à 4, dans lequel le constructeur (4) est agencé pour calculer les coefficients de caractérisation (alph(j)(k)) selon la formule suivante :
où z(j)(k,i) est l'élément d'indice i dans l'estimateur z(j)(k) pour le k-ième jeu de temps d'exécution de caractérisation et T est le nombre d'éléments du jeu de temps d'exécution de référence MO.
Dispositif selon l'une des revendications 2 à 5, dans lequel le constructeur (4) est agencé pour calculer les nouveaux temps d'exécution de caractérisation (Mk(T+j)) selon la formule suivante :
où N(m,s) désigne la loi normale de moyenne m et de variance s, Mk(i) désigne le temps d'exécution d'indice i dans le k-ième jeu de temps d'exécution de caractérisation (Mk), et sig(j-l)(k) est la variance pour le k-ième jeu de temps d'exécution de caractérisation (Mk).
Dispositif selon l'une des revendications 2 à 6, dans lequel le constructeur (4) est agencé pour calculer les nouveaux temps d'exécution de référence (M0[T+j]) selon la formule suivante :
où M0(i) désigne le temps d'exécution d'indice i dans le jeu de temps d'exécution de référence, Mk(i) désigne le temps d'exécution d'indice i dans le k-ième jeu de temps d'exécution de caractérisation (Mk), et alph(j)(k) est le coefficient de caractérisation associé au k-ième jeu de temps d'exécution de caractérisation (Mk) dans la j-ième itération. Dispositif de calcul d'une base de temps d'exécution pire-cas d'un programme par un processeur (P) comprenant une mémoire (8) agencée pour recevoir des données de programme (TP), des jeux de données de configuration de caractérisation (F[k]) et un jeu de coefficients de caractérisation (alph[k]) obtenu par l'exécution du dispositif selon l'une des revendications précédentes,
et un modélisateur (6) agencé pour :
déterminer une pluralité de jeux de valeurs d'initialisation (V) pour chaque jeu de données de configuration de caractérisation (F[k]), le nombre (Ent(R/K)) de jeux de valeurs d'initialisation (V) étant le même pour tous les jeu de données de configuration de caractérisation (F[k]),
déterminer une pluralité de temps d'exécutions (Mk[j]) en exécutant le programme (TP) par le processeur (P) configuré avec chaque jeu de données de configuration de caractérisation (F[k]) et avec à chaque fois la pluralité de jeux de valeurs d'initialisation (V) correspondante, et
ajouter dans une base de temps d'exécution pire-cas une pluralité de temps d'exécution pire-cas (MTP0[j+l]), qui sont chacun égaux à la somme pour chaque les jeux de données de configuration de caractérisation (F[k]) du produit d'un des temps d'exécutions (Mk[j]) par le coefficient de caractérisation (alph[k]) associé au jeu de données de configuration de caractérisation (F[k]) qui a permis d'obtenir ce temps d'exécution (Mk[j]), de sorte que la base de temps d'exécution pire-cas comprend un nombre de temps d'exécution (MTP0[j+l]) égale au nombre de jeux de valeurs d'initialisation (V) pour chaque jeu de données de configuration de caractérisation (F[k]). Procédé de caractérisation de temps d'exécution par un processeur (P), comprenant les opérations suivantes :
a) recevoir des données de programme banc (B), des jeux de données de configuration de caractérisation (F[k]) et des jeux de données de cas d'exécution (S),
b) pour chaque jeu de données de cas d'exécution (S), déterminer un jeu de données de configuration pire-cas du processeur (F) et un jeu de valeurs d'initialisation (V) à partir d'un jeu de données de cas d'exécution (S), et déterminer un temps d'exécution de référence (M0[i]) en exécutant le programme banc (B) selon le jeu de données de cas d'exécution (S) par le processeur (P) configuré avec le jeu de données de configuration (F) avec le jeu de valeurs d'initialisation (V), l'ensemble des temps d'exécution de référence formant un jeu de temps d'exécution de référence (MO),
c) pour chaque jeu de données de configuration de caractérisation (F[k]), déterminer un jeu (Mk) de temps d'exécution de caractérisation (Mk[j]), chaque jeu (Mk) de temps d'exécution de caractérisation (Mk[j]) comprenant un nombre de temps d'exécution de caractérisation (Mk[j]) égal au nombre (T) d'éléments du jeu de temps d'exécution de référence (MO) et chaque temps d'exécution de caractérisation (Mk[j]) étant déterminé en exécutant le programme banc (B) par le processeur (P) configuré avec un jeu de données de configuration de caractérisation (F[k]) et avec un jeu de valeurs d'initialisation (V) représentatif du programme banc (B) et du processeur (P),
d) déterminer un jeu de coefficients de caractérisation (alph[k]) en appliquant un algorithme de détermination du maximum de vraisemblance entre le jeu de temps d'exécution de référence (MO) et les jeux de temps d'exécution de caractérisation (M[k]), et
e) retourner le jeu de données de configuration de caractérisation (F) et le jeu de coefficients de caractérisation (alph[k]).
10. Procédé de calcul d'une base de temps d'exécution pire- d'un programme par un processeur (P) comprenant les opérations suivantes :
a) recevoir des données de programme (TP), des jeux de données de configuration de caractérisation (F[k]) et un jeu de coefficients de caractérisation (alph[k]) obtenu par l'exécution du dispositif selon l'une des revendications 1 à 7 ou le procédé selon la revendication 9,
b) déterminer une pluralité de jeux de valeurs d'initialisation (V) pour chaque jeu de données de configuration de caractérisation (F[k]), le nombre (Ent(R/K)) de jeux de valeurs d'initialisation (V) étant le même pour tous les jeu de données de configuration de caractérisation (F[k]), c) déterminer une pluralité de temps d'exécutions (Mk[j]) en exécutant le programme (TP) par le processeur (P) configuré avec chaque jeu de données de configuration de caractérisation (F[k]) et avec à chaque fois la pluralité de jeux de valeurs d'initialisation (V) correspondante, et
d) ajouter dans une base de temps d'exécution pire-cas une pluralité de temps d'exécution pire-cas (MTP0[j+l]), qui sont chacun égaux à la somme pour chaque les jeux de données de configuration de caractérisation (F[k]) du produit d'un des temps d'exécutions (Mk[j]) par le coefficient de caractérisation (alph[k]) associé au jeu de données de configuration de caractérisation (F[k]) qui a permis d'obtenir ce temps d'exécution (Mk[j]), de sorte que la base de temps d'exécution pire-cas comprend un nombre de temps d'exécution (MTP0[j+l]) égale au nombre de jeux de valeurs d'initialisation (V) pour chaque jeu de données de configuration de caractérisation (F[k]).
EP18737666.0A 2017-06-12 2018-06-06 Dispositif de caracterisation et/ou de modelisation de temps d'execution pire-cas Pending EP3639140A1 (fr)

Applications Claiming Priority (2)

Application Number Priority Date Filing Date Title
FR1755208A FR3067482A1 (fr) 2017-06-12 2017-06-12 Dispositif de caracterisation et/ou de modelisation de temps d'execution pire-cas
PCT/FR2018/051310 WO2018229392A1 (fr) 2017-06-12 2018-06-06 Dispositif de caracterisation et/ou de modelisation de temps d'execution pire-cas

Publications (1)

Publication Number Publication Date
EP3639140A1 true EP3639140A1 (fr) 2020-04-22

Family

ID=60019994

Family Applications (1)

Application Number Title Priority Date Filing Date
EP18737666.0A Pending EP3639140A1 (fr) 2017-06-12 2018-06-06 Dispositif de caracterisation et/ou de modelisation de temps d'execution pire-cas

Country Status (4)

Country Link
US (1) US11748530B2 (fr)
EP (1) EP3639140A1 (fr)
FR (1) FR3067482A1 (fr)
WO (1) WO2018229392A1 (fr)

Families Citing this family (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN111858272B (zh) * 2020-06-29 2023-07-14 深圳优地科技有限公司 判断程序执行延迟方法、装置及终端设备

Family Cites Families (22)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
FR1551828A (fr) 1967-01-31 1968-12-27
GB0019341D0 (en) * 2000-08-08 2000-09-27 Easics Nv System-on-chip solutions
EP1331565B1 (fr) * 2002-01-29 2018-09-12 Texas Instruments France Etablissement de profil d'exécution d'applications en conjonction avec une machine virtuelle
US20050010907A1 (en) * 2003-07-07 2005-01-13 Namjoshi Kedar Sharadchandra Method and apparatus for reducing a program size while maintaining branching time properties and automated checking of such reduced programs
US7574695B2 (en) * 2003-12-23 2009-08-11 Ntt Docomo, Inc. Performing checks on the resource usage of computer programs
US8756044B2 (en) * 2005-05-31 2014-06-17 The Mathworks, Inc. Graphical partitioning for parallel execution of executable block diagram models
US8209701B1 (en) * 2007-09-27 2012-06-26 Emc Corporation Task management using multiple processing threads
EP2192492B1 (fr) * 2008-11-24 2012-11-14 Barcelona Supercomputing Center-Centro Nacional de Supercomputación Procédé, mécanisme et produit de programme informatique pour l'exécution de plusieurs tâches dans un processeur multifilière et pour estimer les temps d'éxecution des tâches les plus défavorables
US8316368B2 (en) * 2009-02-05 2012-11-20 Honeywell International Inc. Safe partition scheduling on multi-core processors
WO2012005639A1 (fr) * 2010-07-06 2012-01-12 Saab Ab Simulation et essai d'avionique
US9477928B2 (en) * 2010-07-14 2016-10-25 Fujitsu Limited System and method for comparing software frameworks
US9158592B2 (en) * 2011-05-02 2015-10-13 Green Hills Software, Inc. System and method for time variant scheduling of affinity groups comprising processor core and address spaces on a synchronized multicore processor
GB2491564A (en) * 2011-05-24 2012-12-12 Isis Innovation Method of system monitoring
US8875146B2 (en) * 2011-08-01 2014-10-28 Honeywell International Inc. Systems and methods for bounding processing times on multiple processing units
US9081583B2 (en) * 2012-08-23 2015-07-14 National Instruments Corporation Compile time execution
US9612868B2 (en) * 2012-10-31 2017-04-04 Honeywell International Inc. Systems and methods generating inter-group and intra-group execution schedules for instruction entity allocation and scheduling on multi-processors
FR3004825B1 (fr) * 2013-04-19 2015-04-24 Krono Safe Procede d'allocation temporelle de taches permettant une recuperation d'erreur deterministe en temps reel
US20160247081A1 (en) * 2015-02-23 2016-08-25 Honeywell International Inc. Worst-case execution time statistical tool
FR3033431A1 (fr) * 2015-03-04 2016-09-09 Inria Inst Nat De Rech En Informatique Et En Automatique Dispositif de simulation
US10733526B2 (en) * 2015-12-09 2020-08-04 International Business Machines Corporation Estimation of latent waiting and service times from incomplete event logs
US20180173622A1 (en) * 2016-12-16 2018-06-21 Hamilton Sundstrand Corporation Deterministic timing evaluation
WO2018115970A1 (fr) * 2016-12-19 2018-06-28 (Un)Manned N.V. Procédé et appareil permettant l'exécution d'une application de boucle de commande en temps réel à partir d'une description de haut niveau

Also Published As

Publication number Publication date
FR3067482A1 (fr) 2018-12-14
US11748530B2 (en) 2023-09-05
WO2018229392A1 (fr) 2018-12-20
US20200159974A1 (en) 2020-05-21

Similar Documents

Publication Publication Date Title
Johannes Deconvolution with unknown error distribution
CA2943397C (fr) Procede d'estimation du caractere normal ou non d'une valeur mesuree d'un parametre physique d'un moteur d'aeronef
WO2017220923A1 (fr) Procédé d'estimation du facteur d'intensité des contraintes et procédé de calcul de durée de vie associé
WO2011007058A1 (fr) Simulation d'un agrégat évolutif du monde réel, notamment pour gestion de risque
US8732223B2 (en) Deriving a function that represents data points
FR3095042A1 (fr) Procede de definition d’un chemin
US9524481B2 (en) Time series technique for analyzing performance in an online professional network
EP3639140A1 (fr) Dispositif de caracterisation et/ou de modelisation de temps d'execution pire-cas
WO2008007026A2 (fr) Procédé de modélisation de l'activité de commutation d'un circuit numérique
US20070124353A1 (en) System and method for generating a probability distribution of computer performance ratios
FR3110725A1 (fr) Procédé mis en oeuvre par ordinateur pour générer des modèles additifs généralisés
EP3265915B1 (fr) Dispositif de simulation
Sainte-Marie et al. Indices de Sobol généralisés aux variables dépendantes: tests de performance de l’algorithme HOGS couplé à plusieurs estimateurs paramétriques
FR3039677A1 (fr) Procede de conception de pieces mecaniques, notamment d'aubes de turbomachine
WO2015067881A2 (fr) Procede et dispositif de caracterisation d'un signal
FR3094816A1 (fr) Procédé et dispositif d’estimation de valeurs d’une métrique additive
EP1688872A2 (fr) Outil informatique de prévision
EP3459177A1 (fr) Procédé de traitement d'un signal formé d'une séquence d'impulsions
FR3093878A1 (fr) Procédé et dispositif d’estimation de distributions probabilistes d’une métrique additive
CN111753949B (zh) 一种数据块处理方法、装置及电子设备
FR3063358A1 (fr) Procede d'estimation du temps d'execution d'une partie de code par un processeur
FR3084192A1 (fr) Procede de rendu d'une scene tridimensionnelle, programme d'ordinateur et dispositif correspondants
WO2023135379A1 (fr) Detection d'anomalies de mesure par filtre de kalman appliquee a la navigation
EP3908926A1 (fr) Procédé de validation d'un système flots de données
EP4187388A1 (fr) Procede et dispositif de detection de comportement aberrant dans un ensemble d'executions d'applications logicielles

Legal Events

Date Code Title Description
STAA Information on the status of an ep patent application or granted ep patent

Free format text: STATUS: UNKNOWN

STAA Information on the status of an ep patent application or granted ep patent

Free format text: STATUS: THE INTERNATIONAL PUBLICATION HAS BEEN MADE

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

STAA Information on the status of an ep patent application or granted ep patent

Free format text: STATUS: REQUEST FOR EXAMINATION WAS MADE

17P Request for examination filed

Effective date: 20191209

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

DAV Request for validation of the european patent (deleted)
DAX Request for extension of the european patent (deleted)
STAA Information on the status of an ep patent application or granted ep patent

Free format text: STATUS: EXAMINATION IS IN PROGRESS

17Q First examination report despatched

Effective date: 20211214

P01 Opt-out of the competence of the unified patent court (upc) registered

Effective date: 20230527