WO2019063930A1 - Procédé d'exécution d'un programme par un appareil électronique - Google Patents

Procédé d'exécution d'un programme par un appareil électronique Download PDF

Info

Publication number
WO2019063930A1
WO2019063930A1 PCT/FR2018/052353 FR2018052353W WO2019063930A1 WO 2019063930 A1 WO2019063930 A1 WO 2019063930A1 FR 2018052353 W FR2018052353 W FR 2018052353W WO 2019063930 A1 WO2019063930 A1 WO 2019063930A1
Authority
WO
WIPO (PCT)
Prior art keywords
function
signature
prerecorded
microprocessor
executed
Prior art date
Application number
PCT/FR2018/052353
Other languages
English (en)
Inventor
Henri-Pierre CHARLES
Anca MOLNOS
Sorin Cotofana
Lucian Petrica
Original Assignee
Commissariat a l'énergie atomique et aux énergies alternatives
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by Commissariat a l'énergie atomique et aux énergies alternatives filed Critical Commissariat a l'énergie atomique et aux énergies alternatives
Publication of WO2019063930A1 publication Critical patent/WO2019063930A1/fr

Links

Classifications

    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F8/00—Arrangements for software engineering
    • G06F8/40—Transformation of program code
    • G06F8/41—Compilation
    • G06F8/44—Encoding
    • G06F8/443—Optimisation
    • G06F8/4441—Reducing the execution time required by the program code
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F8/00—Arrangements for software engineering
    • G06F8/40—Transformation of program code
    • G06F8/41—Compilation
    • G06F8/45—Exploiting coarse grain parallelism in compilation, i.e. parallelism between groups of instructions
    • G06F8/451—Code distribution
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/44—Arrangements for executing specific programs
    • G06F9/448—Execution paradigms, e.g. implementations of programming paradigms
    • G06F9/4482—Procedural
    • G06F9/4484—Executing subprograms
    • G06F9/4486—Formation of subprogram jump address

Definitions

  • the invention relates to a method of executing a program by an electronic device. It also relates to an information recording medium and an electronic device for the implementation of this method.
  • the electronic apparatus typically comprises a non-reconfigurable microprocessor and a configurable hardware accelerator.
  • a non-reconfigurable microprocessor For example, such a method and such an electronic apparatus are disclosed in US6077315.
  • one of the difficulties encountered is to identify and automatically select the program functions to be executed by the hardware accelerator instead of being executed by the microprocessor.
  • this selection of the functions to be performed by the hardware accelerator is done manually during the design of the program.
  • specific instructions are inserted to indicate that a particular function of the program must be executed by the hardware accelerator and not by the microprocessor. After compilation of this program, these instructions are transformed into corresponding instructions in the machine code of the executable program.
  • programs specially designed and compiled for this purpose can benefit from the possibilities offered by the presence of the hardware accelerator to accelerate the execution of these programs.
  • the application US2015 / 046427A1 also describes the use of a hardware accelerator to speed up the execution of queries on a database.
  • the invention aims to remedy these disadvantages. It therefore relates to a method of executing a program according to claim 1.
  • Embodiments of this method may include one or more of the features of the dependent claims.
  • the invention also relates to a microprocessor-readable information recording medium on which a computer program is recorded, comprising computer program code instructions for the execution of the steps of the method. claimed, when these instructions are executed by the microprocessor.
  • the invention also relates to an electronic device configured for the implementation of the claimed method.
  • FIG. 1 is a schematic illustration of the architecture of an electronic device capable of executing a program
  • FIGS. 2 to 5 are schematic illustrations of different data structures used by the apparatus of FIG. 1;
  • FIGS. 6 and 7 are diagrammatic illustrations of the pseudo code, respectively, of a first and a second function of a program executable by the apparatus of FIG. 1;
  • FIG. 8 is a partial illustration of the source code of a third function of the program executable by the apparatus of FIG. 1;
  • FIG. 9 is a flowchart of a method of executing a program by the apparatus of FIG. 1;
  • FIG. 10 is a schematic illustration of a grid that can be used to identify a function of the program executed by the apparatus of FIG. 1;
  • FIG. 11 and 12 are schematic illustrations of two variants of the architecture of the apparatus of Figure 1.
  • a "program” designates a set of one or more predetermined functions that it is desired to execute by a microprocessor.
  • a "source code” is a representation of the program in a computer language, not being directly executable by a microprocessor and being intended to be converted by a compiler or an interpreter into a machine code directly executable by the microprocessor.
  • a program or code is said to be "directly executable” when it is able to be executed by a microprocessor without this microprocessor having to first compile it by means of a compiler or to interpret it. by means of an interpreter.
  • An "instruction” designates a machine instruction executable by a microprocessor. Such an instruction consists of:
  • an opcode, or operation code coding the nature of the operation to be executed, and one or more operands defining the value or values of the parameters of this operation.
  • a "machine code” is a set of machine instructions. This is typically a file containing a succession of bits carrying the value "0" or "1", these bits encoding the instructions to be executed by the microprocessor.
  • the machine code is directly executable by the microprocessor, that is to say without requiring a compilation or a prior interpretation.
  • a “binary code” is a file containing a succession of bits carrying the value "0" or "1". These bits encode data and instructions to be executed by the microprocessor.
  • the binary code comprises at least one machine code and in addition, generally, digital data processed by this machine code.
  • a "flow of instructions” is a succession of instructions classified one after the other and which forms, in the machine code, an ordered sequence of bits.
  • the flow of instructions begins with an initial instruction and ends with a final instruction.
  • this stream of instructions in memory is divided into a succession of basic blocks immediately consecutive or separated by blocks of data.
  • a "base block” is a group of successive instructions of the instruction stream that starts at a branch address and ends with a single explicit or implicit branch instruction.
  • An explicit branch instruction is characterized by the explicit presence of an opcode in the machine code that encodes the branch instruction.
  • An implicit branching instruction corresponds to the case where the execution of a previous base block always proceeds by executing a next base block located in the machine code immediately after the previous base block. In this case, since in the absence of an explicit branch instruction, the instructions of the machine code are executed in order one after the other, it is not necessary to introduce at the end of the basic block preceding an explicit branch instruction to the next base block. In this description, it is said that in this case, the previous base block ends with an implicit branch instruction because it is not explicitly coded in the machine code.
  • the previous base block terminates just before the branch address of the next base block.
  • all that is described in the case of explicit branching instructions also apply to implicit branching instructions.
  • the expression "branch instruction” thus designates both an explicit and implicit branch instruction.
  • the execution of a base block systematically begins with the execution of the instruction located at its initial address and ends systematically with the execution of the branch instruction that ends this base block.
  • a base block has no other branching instructions than the one at the end of this base block.
  • the instructions of a basic block are always read by the microprocessor one after the other in the order in which they are present in this basic block.
  • the branch instruction can direct, when executed, the control flow systematically to the same branch address or, alternately, to different branch addresses. This last case occurs, for example, when at the end of the base block executed, the control flow can continue to a first and, alternately, to a second base block.
  • a "branch instruction” is an instruction which, when executed by the microprocessor, triggers a jump to the branch address of another base block.
  • This branch instruction therefore comprises at least the branch address of this other base block.
  • this instruction replaces the current value of the ordinal counter with the value of the branch address.
  • the ordinal counter contains the address of the next instruction to be executed by the microprocessor.
  • the instructions are systematically executed sequentially one after the other in the order in which they are stored in a main memory.
  • the branch instruction can be unconditional, ie the jump to the branch address is always performed as soon as this instruction is executed.
  • An unconditional branch instruction is for example the "JMP" statement in assembly language for the x86 series microprocessors.
  • the branch instruction can also be conditional, that is, the jump to the branch address is triggered when it is executed only if a particular condition is true.
  • a conditional branch instruction is an assembly "JE", "JA", or "JNE" instruction.
  • the branch instruction can be a call to a function as well.
  • the term "branch instruction” refers to both direct and indirect branching instructions.
  • a direct branch instruction is a branch instruction that directly contains the numeric value of the branch address.
  • An indirect branch instruction is a branch instruction to a branch address contained in a memory or a register of the microprocessor. Thus, unlike a direct branch instruction, an indirect branch instruction does not directly contain the digital value of the branch address.
  • a "branch address” is the address in the main memory to which the first instruction executed from a base block is located. Subsequently, we speak of branch address even for the basic blocks whose first instruction is executed following the execution of an implicit branch instruction.
  • FIG. 1 represents an electronic device 2 comprising an electronic computer 4, a main memory 6 and, optionally, an information recording medium 8.
  • the apparatus 2 is a computer, a smartphone, an electronic tablet or the like.
  • the computer 4 is a reconfigurable electronic calculator such as that described in detail in the patent US6077315. Thus, here, only a brief description of this calculator 4 is given. Reference is made to patent US 6077315 for a more detailed description of the architecture of computer 4 and more specifically to the description given with reference to FIGS. 1, 2, 2A and 2B of this patent.
  • the electronic calculator 4 comprises:
  • the microprocessor 10 is a conventional microprocessor capable of executing any program recorded in the memory 6. This microprocessor 10 is not reconfigurable in the sense that its hardware architecture is not configurable. In addition, unlike the microprocessor 106 of US Pat. No. 6,077,315, the microprocessor 10 is a conventional microprocessor which has not been modified to be able to execute specific instructions for transferring the execution of a function to the accelerator 12.
  • the microprocessor 10 is a microprocessor MSP430, marketed by the company TEXAS INSTRUMENTS®.
  • the accelerator 12 is said to be “configurable” because its hardware architecture can be modified in response to the loading in this accelerator 12 of a game configuration instructions.
  • the accelerator 12 is, for example, an FPGA ("Field Programmable Gate Array") component such as that described in patent US 6077315.
  • the memory 6 includes a program 28 to execute.
  • the program 28 may be a program capable of controlling electronic devices such as a human-machine interface or a printer. It can also be a program capable of acquiring data transmitted by electronic sensors and then processing them. It may also be a program that processes technical data such as a computer-aided simulation program. More generally, the teaching given here applies to any type of program executed by a microprocessor.
  • program 28 is not directly written in the machine language of the microprocessor 2, but in an intermediate language independent of the specificities of the hardware architecture of the device 2 on which this program should be run.
  • program 28 is written in Bytecode, such as Bytecode Java®.
  • the program 28 has many functions and, in particular, parametric functions.
  • a parameterized function is a function that comprises at least one parameter whose value is obtained at the moment when this function is called to be executed by the microprocessor 10 or during its execution by the microprocessor 10.
  • a parameter is an argument of the function whose value is obtained at the moment when this function is called to be executed by the microprocessor 10. It is said that the parameter is explicit because it is explicitly mentioned as an argument of the function whose value must be provided for the function to be performed. This is the most common case for a parameterized function.
  • Such a global variable is usually declared at the beginning of the program and can be used within all functions of the program without the need for this global variable to appear explicitly in the argument list of these functions.
  • a global variable can be used to hold the size of an image or a matrix.
  • Another example of an implicit parameter is a variable intended to contain a value returned by a subfunction called by the function.
  • each parameter is coded as a variable in the code of the parameterized function.
  • the code of each parameterized function contained in the program 28 includes read operations of the value of each parameter in a memory before being able to process this parameter.
  • the value of the parameter is used, within the generic code of the function, as operand of one or more operations to be performed. It can be any operation. For example, these operations are arithmetic, boolean, or read operations of data at an address specified by the parameter value.
  • the parameter may also be of a non-functional nature. For example, it contains information on the characteristics of the microarchitecture of the microprocessor 10 on which the program 28 will be executed.
  • a function corresponds to at least one basic block.
  • a function is not limited to a single base block and may have several basic blocks whose executions must be chained one after the other.
  • the program 28 comprises the code of three generic functions parameterized noted, respectively, F, G and H.
  • These three generic functions F, G and H are represented, under pseudocode form understandable by those skilled in the art, respectively, in Figures 6 to 8.
  • the generic function F performs the multiplication of two matrices A and B and records the result in a matrix R.
  • the parameters of the function F are the addresses where matrices A, B and R start and the dimensions of these matrices.
  • the memory 6 also comprises:
  • Each of these codes 30 and 34 is preferably written in the machine language of the microprocessor 10 and therefore directly executable by this microprocessor.
  • the interpreter 30 is also known by the term "virtual machine" in the particular case of Bytecode Java.
  • the interpreter 30 contains a set of machine language routines associated with each instruction contained in the Bytecode instruction set.
  • the interpretation consists in executing the machine language routine corresponding to each Bytecode instruction of the program 28.
  • the manager 34 has the function of managing the execution flow programs executed such as the program 28. In particular, as will be described in more detail below, the manager 34 is able to direct to the accelerator 12 performing a predetermined function.
  • the memory 6 also includes a database 36 of configurations and a table 38.
  • FIG. 2 schematically represents the architecture of the base 36.
  • the base 36 here comprises several different sets of instructions for configuring the accelerator 12.
  • the accelerator 12 are files each containing a binary representation of a configuration of the accelerator 12.
  • Such a set of instructions can be obtained by compiling a configuration of the accelerator 12 described using, for example, the VHDL language ("VHSIC hardware description language").
  • VHSIC hardware description language VHSIC hardware description language
  • F spe i, G spe i and H spe i the predetermined functions performed by the accelerator 12 when loaded with, respectively, the games Jl, J2 and J3.
  • these functions Fspel, Gspel and Hs ei respectively correspond to generic functions F, G and H but specialized with predetermined values for their parameters.
  • the function F spe i is identical to the function F in the particular case where the dimensions of the matrices A, B and R are equal to, respectively, [6 ⁇ 5], [5 ⁇ 7] and [6 ⁇ 7] ].
  • the symbol [l x xl y ] indicates the number of rows (l x ) and the number of columns (l y ) of the matrix.
  • the function F i is identical to the function F but specialized with the values 6, 7 and 5, respectively MaxLine parameters MaxColumn and maxelement of the function F shown in Figure 6.
  • the number of parameters whose values must be supplied to the function F spe i is therefore smaller than in the case of the function F.
  • the function F spe i still admits three parameters which are the addresses of matrices A, B and R. Thus, even when the function F i is performed by the accelerator 12, the values of these three remaining parameters are provided to the accelerator 12.
  • the base 36 associates one or more different prerecorded signatures. For example, here, the base 36 associates three signatures SU, S12 and S13 to the set J1, a signature S21 to the set J2 and four signatures S31 to S34 to the set J3.
  • each of these signatures allows the manager 34 to identify, during the execution of the program 28, that a predetermined function is currently performed by the microprocessor 10.
  • the signatures SU to S13 identify the function F se i
  • the signature S21 makes it possible to identify the function G se i
  • the signatures S31 to 34 make it possible to identify the function H se i.
  • a first exemplary embodiment is described below in the particular case of the signature SU.
  • the SU signature ( Figure 3) comprises at least one sequence of opcodes identifiers listed in the order in which these opcodes are executed when the function F i is performed by the microprocessor 10.
  • this sequence is represented by the symbol "Seqll".
  • the sequence of opcode identifiers need not contain the identifiers of all the opcodes executed by the microprocessor 10 when it performs this function.
  • the sequence of opcode identifiers contains only the most characteristic opcode identifiers of the predetermined function and not all the identifiers of the opcodes executed during the realization of this predetermined function.
  • the prerecorded signature may then comprise in addition a prerecorded cartography of at least a part memory accesses observed when the microprocessor 10 performs this predetermined function.
  • the SU signature includes a prerecorded Call map.
  • the relative positions, that is to say relative to each other, of the different machine words accessed in memory 6 during the performance of the function by the microprocessor 10 is also a specific characteristic of the predetermined function . It can therefore help unambiguously identify this function among other possible functions. This characteristic is independent of the order in which the opcodes of the predetermined function are executed by the microprocessor 10.
  • word-machine is meant a group of fixed size of elementary memory cells manipulated as a single entity by the opcodes of the machine-language of the microprocessor 10. Typically, the size of a word-machine is therefore often equal to 8, 16, 32 or 64 bits.
  • Each map comprises at least one description of the arrangement in the memory of a set of N words-machine, where N is an integer greater than or equal to 4, 10 or 20.
  • this description defines the positions relative, that is to say relative to each other, N machine words of this set.
  • the N machine words selected to be part of the same set can be:
  • Call mapping comprises:
  • the descriptions Enll, Enl2 and Enl3 are independent of each other. In other words, any modification of one of these descriptions has no influence on the other descriptions.
  • the descriptions En11, Enl2 and Enl3 do not specify that they are the opcodes executed before or after the access to each of these machine words.
  • the description Enll defines an arrangement of 35 machine words contiguous to each other and forming a matrix of six rows and five columns,
  • Figure 4 shows another possible embodiment of a prerecorded signature. This other embodiment is described in the particular case of the S12 signature.
  • the signature S12 comprises a map Cal2 containing a description E R of the arrangement of the 42 machine words forming the matrix R.
  • the description E R is identical to the description Enl3.
  • the description E R associates, with each machine word of the matrix R, a sequence of opcode identifiers executed just before or after writing in this machine word.
  • each machine word of the set E R is associated with the sequence Seql2 of subsequent opcode identifiers ⁇ IdM; IdA ⁇ executed before each write in a machine word of the matrix R, where
  • IdM is the identifier of the opcode which, when it is executed by the microprocessor 10, carries out a multiplication
  • IdA is the identifier of the opcode which, when executed by the microprocessor 10, performs an addition.
  • each write in a machine word of the matrix R is preceded by a multiplication and an addition.
  • sequence Seql2 replaces the Seqll sequence.
  • the same predetermined function can be programmed and compiled in different ways. There are therefore generally several possible implementation variants to achieve the same function. For example, instead of using the algorithm of FIG. 6 to perform a multiplication of matrices, it is also possible to use the algorithm known as "tiled matrix multiply algorithm" and described in the article "Matrix multiplication algorithm” of the site https://en.wikipedia.org. Each implementation variant may correspond to a different signature constructed according to one of the embodiments described herein. Therefore, preferably, the same set J1 is associated with several different signatures each corresponding to a respective variant of implementation of the same function F spe i. In Figure 2, this is also the case for the game J3.
  • FIG. 5 diagrammatically represents an example of possible architecture for the table 38.
  • the function of the table 38 is to associate the address, in the program 28 where the execution of a predetermined function begins, with the set of configuration instructions which, when loaded into the accelerator 12, allows this accelerator to perform this function.
  • the table 38 contains the address @F spe i where the execution of the function F starts in the program 28.
  • the address @F spe i is typically equal to the branch address of the first block of
  • the address @ F spe i is loaded into the ordinal counter of the microprocessor 10, for example, following the execution of a branch instruction.
  • the branch instruction can be a conditional or non-conditional jump or a call to a function.
  • the table 38 associates with this address @F spe i, the values of the various parameters of the function F with which it must be specialized so that its execution can be transferred to the accelerator 12.
  • the table 38 associates at the address @F se i the values 6, 7 and 5 respectively of the MaxLine, MaxColumn and MaxElement parameters.
  • FIG. 6 represents, in the form of a pseudo-code understandable by those skilled in the art, the generic function F which can be specialized to obtain the function F spel .
  • this function F is the function that multiplies matrices A and B, respectively, of dimensions [MaxLine; MaxElement] and [MaxElement; MaxColumn] and save the result in the dimension matrix R [MaxLine; MaxColumn].
  • the parameters of this generic function F are here the addresses @A, @B and @R of the first machine words of the matrices, respectively A, B and R.
  • the parameters of this generic function F are also the dimensions of these matrices designated here by the terms MaxLine, MaxColumn and MaxElement.
  • the function F i corresponds to the function F in the particular case where the MaxLine parameters MaxColumn and maxelement are respectively 6, 7 and 5. here that these parameters is assumed, and in particular the dimensions of the matrices A, B and R , are only known at the time of execution of the program 28.
  • this function F is called with known values for each of its parameters.
  • FIG. 7 represents, in a pseudo-code form understandable by those skilled in the art, the generic function G.
  • This function G is parameterized by three parameters, namely @P, Lmax and Cmax.
  • the parameter @P is the address of the first pixel of an image recorded as a matrix of pixels of Lmax lines and Cmax columns. In this matrix, each cell P [line] [column] corresponds to a 32-bit machine word.
  • the first 8 bits of this word machine code the intensity of red in the RGB color space (Red, Green, Blue).
  • the next 8 bits of this same word machine encodes the intensity of the green in the same space.
  • the next 8 bits of this word machine code the blue always in the same space and the last 8 bits of the word machine code the transparency of the color.
  • Each of these color codes and the transparency must be between 0 and maxval for example.
  • a conventional treatment of this image is to ensure that the value of each color code and the transparency code of each cell of the matrix is between 0 and maxval. If this is not the case, then the current value of the 8 bits concerned is replaced by the value 0 or maxval.
  • the generic function G shown in FIG. 7 performs this image processing.
  • the Extract function (P [line] [column], i) returns the value of the 8-bit range at position i.
  • the signature S21 makes it possible to identify the execution of the function G spe i.
  • the signature S21 is identical to the signature S11 except that the sequence Seq11 is replaced by a sequence Seq21 and the mapping Call is replaced by a map Ca21.
  • the Seq21 sequence comprises a Seq211 primary sequence.
  • the sequence Seq211 is the following ⁇ IdCO; ldC255 ⁇ , where:
  • - ldC255 is the identifier of the comparison opcode at 255.
  • the Seq211 primary sequence is repeated four times in a row to obtain a Seq212 secondary sequence and this Seq212 sequence is repeated a hundred times in a row to obtain the Seq21 sequence.
  • the mapping Ca21 includes a description that defines the relative positions of the 100 machine words of the matrix that contains the pixels of the processed image.
  • the mapping Ca21 can be omitted because, here, the sequence Seq21 is sufficient on its own to unambiguously identify the function
  • the signature S21 could also have been constructed in a manner similar to that described for the signature S12.
  • the function G spe i is also characterized by the fact that after each read access to a pixel of the image, the opcodes identified by the sequence Seq212 are executed. So, a Possible variant of the signature S21 is constructed by associating the sequence Seq212 with each of the 100 machine words whose relative positions are defined by the mapping Ca21.
  • FIG. 8 represents the code, in C language, of the generic function H which calculates the difference between blocks of pixels of two different images.
  • This code comes from the project VideoLAN and more precisely from the file "pixel. It can be downloaded free from the website www.videolan.org.
  • the code for this H function was written by Loren Merritt (lorenm@u.washington.edu), Laurent Aimar (fenrir@via.ecp.fr) and Fiona Glaser (fiona@x264.com). Since this function H is well known, it is not described here in detail. It will be observed only that the function H admits several parameters including:
  • the function H spe i corresponds to the specialized function H with particular values for the width Ix and the height ly of the block.
  • the function H i is characterized, after each read access to a pixel of each of the first and second images, by performing in sequence:
  • the process begins with a step 100, in which the base 36 is constructed. During this step, a programmer develops and designs the different sets of configuration instructions and in particular games J1 to J3.
  • the instruction sets recorded in the base 36 can be chosen according to the knowledge that one has about the functions performed by the 28. They can also be chosen on the basis of other criteria such as statistical knowledge on the interest of implementing a set of instructions in a computer to speed up the execution of a program that is not do not know in advance. Thus, the choice of instruction sets can be done independently of the program or programs that will be executed by the computer 4.
  • the programmer constructs one or more signatures able to identify the predetermined function, corresponding to this set of instructions, when it is executed by the microprocessor 10.
  • Each of these Constructed signatures are registered and associated in the base 36 to the corresponding instruction set.
  • the programmer constructs a signature for each possible variant of implementation of the predetermined function or at least for the usual implementation variants of this predetermined function. Indeed, as already indicated above, the same function can be implemented in different ways in a program so that the presence of different signatures increases the probability that the execution of this predetermined function is correctly identified.
  • the programmer builds in particular the different signatures shown in FIG.
  • the built base 36 is supplied to the computer 4. For example, it is recorded for this purpose in the memory 6.
  • phase 110 the execution of programs by the computer 4 begins.
  • This phase 110 is described later in the particular case of the program 28 and the function F se i. However, what is described in this particular case is generalized without difficulty to any other program and any other predetermined function.
  • the table 38 is empty and no function is configured in the accelerator 12.
  • the program 28 is loaded into the memory 6.
  • step 116 the microprocessor 10 starts executing the interpreter 30.
  • the interpretation consists in executing the routine in machine language corresponding to each Bytecode instruction of the program 28 by scanning them one after the other .
  • step 116 the microprocessor 10 first obtains the values of each parameter of a parameterized function before calling it with the values thus obtained.
  • the call of the function is materialized by a connection to a branch address where the first instruction of the generic code of this function is recorded.
  • the manager 34 is executed by the microprocessor 10.
  • the execution of such a connection corresponds to the call of a function with the values of the parameters obtained during the execution of step 116.
  • the manager 34 checks whether the called function corresponds to the function F spe i configured in the accelerator 12. For this, for example, the manager 34 first checks whether the branch address to which the execution of the code of the program 28 is directed corresponds to the address @ F i stored in the table 38. If so, the manager 34 also checks whether the parameter values with which the function F is called correspond to the values recorded for these parameters in the second column of the table 38. If at least one of these two checks is not performed successfully, then the driver 34 does not trigger the execution of the function F spe i by the accelerator 12. Note that since the table 38 is initially empty, when the first execution of the function F spe i, these two checks fail and the process is continued by the step 124 of collecting the signature of this function described below.
  • the manager 34 detects that the execution by the accelerator 12 of the function F se i must be triggered. In the latter case, here, the accelerator 12 is already currently configured to perform this function F se i. The manager 34 then proceeds to execution of step 120. Thus, in step 118, when the function F i must again be performed, the manager 34 is therefore able to trigger the execution of the function F spe i by the accelerator 12 without necessarily having to repeat the step 124.
  • step 120 the microprocessor 10 triggers the execution of the function F i by the accelerator 12. This function F i is then not executed by the microprocessor 10 but by the accelerator 12 Therefore, here, as the accelerator 12 has not finished executing the function F spe i, the execution of the step 116 is suspended.
  • step 120 when step 120 is executed, it is not necessary to interpret or compile the generic code of the function F, which is already a substantial time saving. Moreover, as explained previously, the throttle 12 runs faster the function F i for the microprocessor 10. Thus, the execution of the function F i is substantially accelerated. At the end of the execution of the function F spe i by the accelerator 12, the execution of the step 116 resumes after the call instructions of the function F spe i.
  • step 118 If at the end of step 118, the manager 34 has not detected the triggering of the execution of the function F se i, it proceeds to the step 124 of collecting a signature of the called function. In parallel, the called function is executed by the For this, the execution of step 116 continues in parallel with step 124.
  • step 124 the manager 34 collects the signature of the called function. For this purpose, here, during the entire duration of the execution of the called function, it collects in the execution order:
  • the sequence of opcodes identifiers executed immediately before and after access to the memory is also collected.
  • sequence of opcodes identifiers executed immediately before a memory access is meant an ordered sequence of opcode identifiers executed only between the previous access to the memory and this access to the memory.
  • sequence of opcodes identifiers executed immediately after a memory access is meant an ordered sequence of opcode identifiers executed only between this memory access and the next.
  • the manager 34 reads all the opcodes identifiers executed during the entire duration of the execution of the called function.
  • the manager 34 For each opcode identifier corresponding to an opcode which, when it is executed by the microprocessor 10, triggers an access to the memory 6, the manager 34 also collects the address of the machine word read or written and associates it with this opcode identifier in the collected opcodes identifier sequence. From such a sequence, it is therefore possible to know which opcodes are executed immediately before and immediately after access to the memory 6. It is also possible to know the type of access to the memory 6 among the two possible access types, that is, read access and write access.
  • the manager 34 compares the collected signature to each of the prerecorded signatures in the base 36.
  • the manager 34 tries to find in the collected sequence of opcodes identifiers executed, a sequence identifiers identical to the prerecorded sequence.
  • a collected sequence is identical to a prerecorded sequence if it has the same identifiers in the same order.
  • the manager 34 deduces that the collected signature corresponds to the prerecorded signature in the base 36. In the opposite case, it deduces that the collected signature does not correspond to this prerecorded signature.
  • the manager 34 searches in the collected sequence of addresses a word-machine arrangement that corresponds to this description.
  • the manager 34 considers that a word-machine arrangement corresponds to a description contained in a prerecorded cartography if this arrangement is identical to that defined by this description.
  • the manager 34 deduces that the collected signature corresponds to the prerecorded signature.
  • the manager 34 searches, in the collected sequence of addresses, an arrangement of read or written machine words which corresponds to the description E R , then
  • the manager 34 verifies that the write or read operation of each of the machine words of this arrangement was immediately preceded or followed by the sequence of opcode identifiers associated with this word machine by the description E R.
  • the above check 2) is performed from the sequence of opcodes identifiers collected.
  • the comparison of the collected signature with the prerecorded signature can also be performed in parallel with the execution of step 124. This is illustrated in the particular case of the signature S12.
  • the manager 34 constructs a grid 130 (FIG. 10) in which each box is arranged relative to the other boxes as defined by the description E R.
  • the grid 130 is a rectangular matrix of six rows and seven columns. It is considered that the address of the box located at the upper left corner of this grid 130 corresponds to the @R address of the matrix R passed as a parameter to the called function.
  • the address of the machine words written in the memory 6 and each cell of this grid 130.
  • the manager 34 checks whether this The write operation was immediately preceded, in order, by a multiplication operation and then an addition operation. If so, the manager 34 marks this box. Otherwise, the manager 34 does not mark this box. In Figure 30, the boxes already marked in the grid 130 are grayed out, while the boxes not yet marked are white.
  • step 124 If at the end of the execution of step 124, all the cells of the grid 130 are marked, then the manager 34 deduces that the collected signature corresponds to the signature S12. In the opposite case, he deduces a lack of correspondence with the signature S12.
  • step 1208 If at the end of the execution of step 128, the manager 34 has determined that the collected signature does not correspond to any of the pre-recorded signatures in the base 36, then the execution of the program 28 continues and the process returns to step 116.
  • the manager 34 If, on the other hand, at the conclusion of the execution of step 128, the manager 34 has determined that the collected signature corresponds to one of the pre-recorded signatures in the base 36, then, during a step 132, the manager 130 loads the set of instructions associated with this prerecorded signature in the accelerator 12. Then, it records in the table 38, instead of the data already present in this table:
  • the manager 34 associates this connection address with the accelerator 12 and thus with the set of configuration instructions previously loaded in the accelerator 12 and which makes it possible to perform the identified function more quickly.
  • FIG. 11 represents an electronic device 150 identical to the electronic device 2, except that:
  • the accelerator 12 is replaced by a coprocessor 152, and
  • the base 36 is replaced by a base 154.
  • the coprocessor 152 is specially designed to execute a type function more quickly than can be done with the microprocessor 10.
  • the coprocessor 152 may be:
  • DSP Digital Signal Processing
  • GPU Graphics Processing Unit
  • the database 154 is identical to the base 36, except that each set of instructions is a machine code of a predetermined function executable directly by the coprocessor 152.
  • This machine code can be optimized for its execution by the computer.
  • the machine code executed by the coprocessor 152 is different from the machine code of the same function executed by the microprocessor 10.
  • the machine code of the function executed by the coprocessor 152 may also be identical to the machine code of the processor. same function performed by the microprocessor 10. In the latter case, the fact that this machine code runs faster on the coprocessor 152 than the microprocessor 10 is explained by differences between the hardware architectures of the coprocessor 152 and the microprocessor 10 .
  • step 132 each time a new predetermined function is identified, an additional line is added in table 38.
  • This additional line includes, in addition to the branch address where the execution of the identified function and the parameter values of this identified function begin, a link to the set of instructions of the database 36 to be executed by the coprocessor 152.
  • the set of instructions to be executed is that associated with the recognized prerecorded signature.
  • the table 38 has several lines.
  • the machine code associated with the table 38 at the address of the called function is executed by the coprocessor 152 to perform this function.
  • FIG. 12 represents an electronic device 160, identical to the device 150, except that the accelerator 12 is omitted and the database 36 is replaced by a database 162.
  • the base 162 is for example identical to the base 154, except that each set of instructions is a machine code of a predetermined function directly executable by the microprocessor 10.
  • the operation of the apparatus 160 is deduced from the explanations given with reference to FIG. 11. However, in the case of the apparatus 160, during the step 120, the associated machine code, by the table 38 at the branch address of the called function is executed by the microprocessor 10 to perform this function. Thus, the execution of the program 28 is made faster because, in this case, it is not necessary to systematically interpret the Bytecode of the predetermined function called.
  • the description of a word-machine arrangement associates with a single or only a few of these machine words, a sequence of opcode identifiers executed immediately after the writing or reading of a message. 'a given in this word-machine. For example, this sequence of opcode identifiers identifies the operations performed on the data immediately after its reading from this word machine.
  • the description of a word-machine arrangement associates with at least one of these machine words a sequence of executed opcode identifiers containing both opcodes identifiers executed immediately before and after after reading or writing in this word machine.
  • sequences of opcode identifiers associated with the machine words by the description of the arrangement of these machine words in memory may be different from each other. These opcode identifier sequences may also differ from one another depending on the type of access to the word machine. For example, the sequence of identifiers associated with the word machine when access to this word machine is write access, is not the same as the sequence of identifiers associated with this same word machine when the access to this same machine-word is read access.
  • machine words of a description of a word-machine arrangement are associated with sequences of opcode identifiers and other machine words of the same description are associated with no sequence of opcode identifiers.
  • a machine word is associated with no sequence of opcode identifiers, it means that the opcodes executed immediately before or after writing or reading in this machine word are not used to identify the function when it is being used. execution by the microprocessor 10.
  • the prerecorded signature of a function does not necessarily include a prerecorded cartography.
  • a word-machine arrangement is not limited to the case where this arrangement corresponds to a matrix in which the machine words are arranged in rows and columns.
  • the description can define layouts any word-machine in memory.
  • a description may define an arrangement of N word words in which the machine words are separated from each other by a regular interval or not but known in advance.
  • the prerecorded cartography may comprise descriptions further defining the relative positions, relative to one another, of the matrices A, B and R.
  • the same prerecorded cartography can comprise descriptions of several different arrangements of word-machines.
  • the base 36 comprises a single set of instructions.
  • the number of signatures associated with the base 36 to the same set of instructions may be greater than that illustrated in the previous examples.
  • the number of prerecorded signatures associated with the same set of instructions may be greater than 5, 10 or 20.
  • the base 36 may also include several different sets of instructions that all correspond to the same generic but specialized function with different values for its parameters.
  • the hardware accelerator is a hardware block known as "IP MATERIAL".
  • This hardware block is preconfigured to execute a predetermined parameterized function.
  • the instruction set loads in the defined hardware block only the parameter values of that specific function.
  • such hardware blocks are known for making Fourier transforms.
  • the accelerator 12 is partitioned into several regions configured independently of each other, so that each of these regions is capable of performing a particular predetermined function.
  • the table 38 has several branch addresses each corresponding to one of the functions currently configured in the accelerator 12.
  • the table 38 includes additional instructions to activate only the region of the accelerator 12 which performs the desired function.
  • the table 38 may comprise several lines, even when the computer 4 uses a hardware accelerator.
  • the predetermined functions are functions only. during the development of the program or when compiling this program. In this case, when running the program, these functions are always executed with the same values of the parameters.
  • the table 38 can then be simplified by deleting the second column. Similarly, it is no longer necessary to record the value of the various parameters of this function to decide whether step 120 should be performed or not.
  • the hardware accelerator is capable of performing a generic function and not a specialized function.
  • the values of all the parameters of the generic function are transmitted to the accelerator 12 at the beginning of the step 120 so that it can correctly perform this function.
  • the machine code associated with the table 38 at a branch address may be the machine code of a generic function and not a specialized function.
  • the configuration of the accelerator 12 can also be performed at other times than during the execution of step 132.
  • the configuration of the accelerator 132 is carried out at the beginning of the process. step 120.
  • step 118 has been described as being triggered by a call to a function.
  • the function whose execution can be accelerated, is not necessarily a function called by a call instruction in the program 28.
  • the function that can be accelerated can also be a basic block of the flow program instructions. In this case, the detection of this function is for example triggered and initialized each time a branch instruction to a new base block is executed.
  • Step 128 can be performed differently. For example, to determine whether the collected signature matches the prerecorded signature, a margin of error can be tolerated and there is no need to confine itself to an identity between these two signatures. For example, alternatively, a correlation rate between the collected signature and the prerecorded signature is calculated. If this correlation rate exceeds a predetermined threshold, then the manager 34 deduces that the collected and prerecorded signatures match. This threshold may be less than the value of the correlation rate that is obtained when the collected signature is identical to the prerecorded signature.
  • the manager 34 may consider that the collected address sequence corresponds to the description of a word-machine arrangement, if the correlation rate between these two elements exceeds a predetermined threshold and this even if it There is not a strict identity between these two elements. If the relative positions of N machine words read or written in memory by the function are sufficient to unambiguously identify this function, the signature of this function does not necessarily include a prerecorded sequence of opcode identifiers.
  • the collected sequence of opcode identifiers is compared with a prerecorded sequence of opcodes, which makes it possible to identify a predetermined function even during the execution of the machine code. program 28. It will be noted that the identification of such a function is possible, without it being necessary to instrument the code of the program to be executed. In particular, it is not necessary to insert instructions in the program that explicitly indicate which functions can be speeded up. Thus, the methods described herein work with any type of executable program and no matter how and by what means this executable program has been written and compiled.
  • the decision to accelerate the execution or not of a program function is taken during the execution of this program and not during its writing or during its compilation.
  • this decision can take into account data and parameters that are only known during the execution of the program. This offers more opportunities to accelerate program execution.
  • the fact of using an opcodes identifier sequence in the signature makes it possible to identify a function independently, in particular, of its name or of its branch address. For example, if the same function exists under two different names in the source code, this does not change the performance of the claimed method when executing the machine code obtained after compilation of this source code.
  • the method described here works even if the executed program is already fully compiled, i.e. it is in the form of a machine code. In particular, it also applies to programs other than those compiled just at the time of execution.
  • the cartography includes a description defining the arrangement of N machine words independently of opcodes executed immediately before or after access by the microprocessor 10 to each of these machine words makes it possible to obtain a signature. more independent vis-à-vis the different possible variants of implementation of this function. With this, the number of signatures to be associated with the same set of instructions can be decreased while by being able to identify the same number of implementation variants of this function.

Landscapes

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

Abstract

Ce procédé d'exécution d'un programme comporte : - lorsqu'une fonction est exécutée par un microprocesseur, la collecte (124) d'une signature de cette fonction, cette collecte comportant la collecte des identifiants des opcodes exécutés, dans leur ordre d'exécution, pour obtenir une séquence collectée d'identifiants d'opcodes, puis - la comparaison (128) de la signature collectée à une signature préenregistrée, puis - si la signature collectée correspond à la signature préenregistrée, l'association (132) de l'adresse de branchement où débute l'exécution de cette fonction, à un jeu d'instructions associé à cette signature préenregistrée, et - si l'exécution du programme retourne à cette adresse de branchement, le déclenchement (120) de l'exécution de ladite fonction prédéterminée par un accélérateur matériel configuré avec ce jeu d'instructions ou le déclenchement de l'exécution par le microprocesseur ou un coprocesseur d'un code-machine de ce jeu d'instructions.

Description

PROCÉDÉ D'EXÉCUTION D'UN PROGRAMME PAR UN APPAREIL ÉLECTRONIQUE
[001] L'invention concerne un procédé d'exécution d'un programme par un appareil électronique. Elle concerne également un support d'enregistrement d'informations ainsi qu'un appareil électronique pour la mise en œuvre de ce procédé.
[002] Il a déjà été proposé d'accélérer l'exécution d'un programme en confiant l'exécution de certaines fonctions de ce programme à un accélérateur matériel. À cet effet, l'appareil électronique comporte typiquement un microprocesseur non reconfigurable et un accélérateur matériel configurable. Par exemple, un tel procédé et un tel appareil électronique sont divulgués dans le brevet US6077315. Dans ces procédés connus, l'une des difficultés rencontrées est d'identifier et de sélectionner automatiquement les fonctions du programme qui doivent être exécutées par l'accélérateur matériel au lieu d'être exécutées par le microprocesseur. Jusqu'à présent, cette sélection des fonctions à exécuter par l'accélérateur matériel est réalisée manuellement lors de la conception du programme. Typiquement, pour cela, dans le code-source du programme, des instructions spécifiques sont insérées pour indiquer que telle ou telle fonction du programme doit être exécutée par l'accélérateur matériel et non pas par le microprocesseur. Après compilation de ce programme, ces instructions sont transformées en instructions correspondantes dans le code-machine du programme exécutable. Ainsi, seuls les programmes spécialement conçus et compilés à cet effet peuvent bénéficier des possibilités offertes par la présence de l'accélérateur matériel pour accélérer l'exécution de ces programmes.
[003] De plus, du fait que les fonctions qui doivent être exécutées par l'accélérateur matériel sont choisies lors de la conception du programme et donc avant sa compilation, il n'est pas possible de tenir compte des valeurs des paramètres de ces fonctions pour décider s'il est opportun ou non de confier leurs exécutions à cet accélérateur matériel. En effet, ces valeurs sont uniquement connues lors de l'exécution du programme et non pas au moment de la conception ou de la compilation du programme.
[004] La demande US2015/046427A1 décrit également l'utilisation d'un accélérateur matériel pour accélérer l'exécution de requêtes sur une base de données.
[005] L'article de Saumya K. DEBRAY et Al : « Compiler technique for code compaction », ACM Transaction on programming langage and Systems, vol. 22, n°l, 1/03/2000, décrit des techniques de factorisation et de compression du code machine d'un programme.
[006] De l'état de la technique est également connu de :
- US2016/179489A1, et
- Caroline QUEVA et Al : « Self-optimisation using runtime code génération for wirelesss sensor networks », Distributed Computing and networking, ACM, 4/01/2016. [007] L'invention vise à remédier à ces inconvénients. Elle a donc pour objet un procédé d'exécution d'un programme conforme à la revendication 1.
[008] Les modes de réalisation de ce procédé peuvent comporter une ou plusieurs des caractéristiques des revendications dépendantes.
[009] L'invention a également pour objet un support d'enregistrement d'informations lisible par un microprocesseur sur lequel est enregistré un programme d'ordinateur, comportant des instructions de code de programme d'ordinateur pour l'exécution des étapes du procédé revendiqué, lorsque ces instructions sont exécutées par le microprocesseur.
[0010] Enfin, l'invention a également pour objet un appareil électronique configuré pour la mise en œuvre du procédé revendiqué.
[0011] L'invention sera mieux comprise à la lecture de la description qui va suivre, donnée uniquement à titre d'exemple non limitatif et faite en se référant aux dessins sur lesquels :
- la figure 1 est une illustration schématique de l'architecture d'un appareil électronique apte à exécuter un programme ;
- les figures 2 à 5 sont des illustrations schématiques de différentes structures de données utilisées par l'appareil de la figure 1 ;
- les figures 6 et 7 sont des illustrations schématiques du pseudo-code, respectivement, d'une première et d'une deuxième fonction d'un programme exécutable par l'appareil de la figure 1 ;
- la figure 8 est une illustration partielle du code source d'une troisième fonction du programme exécutable par l'appareil de la figure 1 ;
- la figure 9 est un organigramme d'un procédé d'exécution d'un programme par l'appareil de la figure 1 ;
- la figure 10 est une illustration schématique d'une grille utilisable pour identifier une fonction du programme exécuté par l'appareil de la figure 1 ;
- les figures 11 et 12 sont des illustrations schématiques de deux variantes de l'architecture de l'appareil de la figure 1.
[0012] Dans ces figures, les mêmes références sont utilisées pour désigner les mêmes éléments. Dans la suite de cette description, les caractéristiques et fonctions bien connues de l'homme du métier ne sont pas décrites en détails.
[0013] Notations et définitions :
[0014] Dans cette description, les définitions suivantes sont adoptées.
[0015] Un « programme » désigne un ensemble d'une ou de plusieurs fonctions prédéterminées que l'on souhaite faire exécuter par un microprocesseur.
[0016] Un « code source » est une représentation du programme dans un langage informatique, n'étant pas directement exécutable par un microprocesseur et étant destiné à être transformé par un compilateur ou un interpréteur en un code machine directement exécutable par le microprocesseur. [0017] Un programme ou un code est dit être « directement exécutable » lorsqu'il est apte à être exécuté par un microprocesseur sans que ce microprocesseur n'ait besoin au préalable de le compiler au moyen d'un compilateur ou de l'interpréter au moyen d'un interpréteur.
[0018] Une « instruction » désigne une instruction machine exécutable par un microprocesseur. Une telle instruction est constituée :
- d'un opcode, ou code d'opération, codant la nature de l'opération à exécuter, et -d'un ou plusieurs opérandes définissant la ou les valeurs des paramètres de cette opération.
[0019] Un « code machine » est un ensemble d'instructions machines. Il s'agit typiquement d'un fichier contenant une succession de bits portant la valeur « 0 » ou « 1 », ces bits codant les instructions à exécuter par le microprocesseur. Le code machine est directement exécutable par le microprocesseur, c'est-à-dire sans nécessiter une compilation ou une interprétation préalable.
[0020] Un « code binaire » est un fichier contenant une succession de bits portant la valeur « 0 » ou « 1 ». Ces bits codent des données et des instructions à exécuter par le microprocesseur. Ainsi, le code binaire comprend au moins un code machine et en plus, généralement, des données numériques traitées par ce code machine.
[0021] Un « flot d'instructions » est une succession d'instructions classées les unes après les autres et qui forme, dans le code machine, une suite ordonnée de bits. Le flot d'instructions débute par une instruction initiale et se termine par une instruction finale. Dans ce texte, ce flot d'instructions en mémoire est découpé en une succession de blocs de base immédiatement consécutifs ou séparés par des blocs de données.
[0022] Un « bloc de base » est un groupe d'instructions successives du flot d'instructions qui débute à une adresse de branchement et qui se termine par une seule instruction de branchement explicite ou implicite. Une instruction de branchement explicite se caractérise par la présence explicite d'un opcode dans le code machine qui code l'instruction de branchement. Une instruction de branchement implicite correspond au cas où l'exécution d'un bloc de base précédent se poursuit systématiquement par l'exécution d'un bloc de base suivant situé, dans le code machine, immédiatement après le bloc de base précédent. Dans ce cas, étant donné qu'en absence d'instruction de branchement explicite, les instructions du code machine sont exécutées dans l'ordre les unes après les autres, il n'est pas nécessaire d'introduire à la fin du bloc de base précédent une instruction de branchement explicite vers le bloc de base suivant. Dans cette description, on dit que dans ce cas, le bloc de base précédent se termine par une instruction de branchement implicite car elle n'est pas explicitement codée dans le code machine. Dans ce cas, le bloc de base précédent se termine juste avant l'adresse de branchement du bloc de base suivant. Dans la suite de cette description, tous ce qui est décrit dans le cas des instructions de branchement explicite s'applique aussi aux instructions de branchement implicites. Dans cette demande, l'expression « instruction de branchement » désigne donc aussi bien une instruction de branchement explicite qu'implicite. Ainsi, l'exécution d'un bloc de base débute systématiquement par l'exécution de l'instruction située à son adresse initiale et se termine systématiquement par l'exécution de l'instruction de branchement qui termine ce bloc de base. Un bloc de base ne comporte pas d'autres instructions de branchement que celle située à la fin de ce bloc de base. Ainsi, les instructions d'un bloc de base sont systématiquement toutes lues par le microprocesseur les unes après les autres dans l'ordre où elles sont présentes dans ce bloc de base. L'instruction de branchement peut diriger, lorsqu'elle est exécutée, le flot de contrôle systématiquement vers la même adresse de branchement ou, en alternance, vers différentes adresses de branchement. Ce dernier cas de figure se rencontre, par exemple, lorsqu'à la fin du bloc de base exécuté, le flot de contrôle peut se poursuivre vers un premier et, en alternance, vers un deuxième bloc de base.
[0023] Une « instruction de branchement » est une instruction qui, lorsqu'elle est exécutée par le microprocesseur, déclenche un saut vers l'adresse de branchement d'un autre bloc de base. Cette instruction de branchement comporte donc au moins l'adresse de branchement de cet autre bloc de base. Typiquement, à cet effet, cette instruction remplace la valeur actuelle du compteur ordinal par la valeur de l'adresse de branchement. On rappelle que le compteur ordinal contient l'adresse de la prochaine instruction à exécuter par le microprocesseur. En absence d'instruction de branchement, à chaque fois qu'une instruction est exécutée, le compteur ordinal est incrémenté de la taille de l'instruction actuellement exécutée. En absence d'instruction de branchement, les instructions sont systématiquement exécutées séquentiellement les unes après les autres dans l'ordre où elles sont enregistrées dans une mémoire principale. L'instruction de branchement peut être inconditionnelle, c'est à dire que le saut vers l'adresse de branchement est systématiquement réalisé dès que cette instruction est exécutée. Une instruction de branchement inconditionnel est par exemple l'instruction « JMP » en langage assembleur pour les microprocesseurs de la série x86. L'instruction de branchement peut aussi être conditionnelle, c'est-à-dire que le saut vers l'adresse de branchement est déclenché lors de son exécution uniquement si une condition particulière est vérifiée. Par exemple, une instruction de branchement conditionnel est une instruction « JE », « JA » ou « JNE » en assembleur. L'instruction de branchement peut aussi bien être un appel à une fonction. Dans ce texte, le terme « instruction de branchement » désigne aussi bien les instructions de branchement direct qu'indirect. Une instruction de branchement direct est une instruction de branchement qui contient directement la valeur numérique de l'adresse de branchement. Une instruction de branchement indirect, est une instruction de branchement vers une adresse de branchement contenue dans une mémoire ou un registre du microprocesseur. Ainsi, contrairement à une instruction de branchement direct, une instruction de branchement indirect ne contient pas directement la valeur numérique de l'adresse de branchement.
[0024] Une « adresse de branchement » est l'adresse dans la mémoire principale à laquelle se trouve la première instruction exécutée d'un bloc de base. Par la suite, on parle d'adresse de branchement même pour les blocs de base dont la première instruction est exécutée suite à l'exécution d'une instruction de branchement implicite.
[0025] On parlera d'exécution d'une fonction pour désigner l'exécution des instructions réalisant cette fonction.
[0026] Description d'un mode de réalisation :
[0027] Dans un souci de simplification, dans cette description et dans les figures, les instructions ne sont pas représentées sous forme binaire, mais plutôt sous une forme symbolique exprimée dans un langage évolué de plus haut niveau, appelé « pseudocode », directement compréhensible par un homme du métier.
[0028] La figure 1 représente un appareil électronique 2 comportant un calculateur électronique 4, une mémoire principale 6 et, éventuellement, un support 8 d'enregistrement d'informations. Par exemple, l'appareil 2 est un ordinateur, un smartphone, une tablette électronique ou similaire.
[0029] Dans ce mode de réalisation, le calculateur 4 est un calculateur électronique reconfigurable tel que celui décrit en détail dans le brevet US6077315. Ainsi, ici, seule une brève description de ce calculateur 4 est donnée. Il est renvoyé au brevet US6077315 pour une description plus détaillée de l'architecture du calculateur 4 et plus précisément à la description donnée en référence aux figures 1, 2, 2A et 2B de ce brevet.
[0030] Le calculateur électronique 4 comporte :
- un microprocesseur 10 non reconfigurable,
- un accélérateur matériel 12 configurable,
- une mémoire cache 14 d'instructions, et
- une mémoire cache 16 de données.
[0031] Le microprocesseur 10 est un microprocesseur classique capable d'exécuter un programme quelconque enregistré dans la mémoire 6. Ce microprocesseur 10 est non reconfigurable dans le sens où son architecture matérielle n'est pas configurable. De plus, contrairement au microprocesseur 106 du Brevet US6077315, le microprocesseur 10 est un microprocesseur conventionnel qui n'a pas été modifié pour être capable d'exécuter des instructions spécifiques pour transférer l'exécution d'une fonction vers l'accélérateur 12.
[0032] Par exemple, le microprocesseur 10 est un microprocesseur MSP430, commercialisé par la société TEXAS INSTRUMENTS®.
[0033] L'accélérateur 12 est dit « configurable » car son architecture matérielle peut être modifiée en réponse au chargement dans cet accélérateur 12 d'un jeu d'instructions de configuration. L'accélérateur 12 est, par exemple, un composant FPGA (« Field-Programmable Gâte Array ») tel que celui décrit dans le brevet US6077315.
[0034] La mémoire 6 comporte un programme 28 à exécuter. Le programme 28 peut être un programme apte à commander des périphériques électroniques tels qu'une interface homme-machine ou une imprimante. Il peut également s'agir d'un programme apte à acquérir des données transmises par des capteurs électroniques, puis à les traiter. Il peut aussi s'agir d'un programme qui traite des données techniques comme par exemple un programme de simulation assistée par ordinateur, De façon plus générale, l'enseignement donné ici s'applique à tout type de programmes exécutés par un microprocesseur.
[0035] Dans ce mode de réalisation, à titre d'illustration, le programme 28 n'est pas directement écrit dans le langage machine du microprocesseur 2, mais dans un langage intermédiaire indépendant des spécificités de l'architecture matérielle de l'appareil 2 sur lequel doit être exécuté ce programme. Par exemple, le programme 28 est écrit en Bytecode, tel que du Bytecode Java®.
[0036] Le programme 28 comporte de nombreuses fonctions et, en particulier, des fonctions paramétrées. Une fonction paramétrée est une fonction qui comporte au moins un paramètre dont la valeur est obtenue au moment où cette fonction est appelée pour être exécutée par le microprocesseur 10 ou pendant son exécution par le microprocesseur 10. Fréquemment, un paramètre est un argument de la fonction dont la valeur est obtenue au moment où cette fonction est appelée pour être exécutée par le microprocesseur 10. On dit alors que le paramètre est explicite, car il figure explicitement comme argument de la fonction dont la valeur doit être fournie pour que la fonction puisse être réalisée. C'est le cas le plus courant pour une fonction paramétrée. Toutefois, il existe aussi des paramètres qui n'apparaissent pas comme étant explicitement des arguments de la fonction, mais dont les valeurs sont lues en mémoire lors de la réalisation de cette fonction. C'est par exemple le cas d'une variable globale. Une telle variable globale est déclarée généralement au début du programme et peut-être utilisée à l'intérieur de toutes les fonctions du programme sans qu'il soit nécessaire que cette variable globale apparaisse explicitement dans la liste des arguments de ces fonctions. Par exemple, une variable globale peut être utilisée pour contenir la taille d'une image ou d'une matrice. Un autre exemple d'un paramètre implicite est une variable destinée à contenir une valeur retournée par une sous-fonction appelée par la fonction.
[0037] Puisque les valeurs des paramètres d'une fonction ne sont pas nécessairement connues au moment où le programme est écrit, mais, par exemple seulement au moment de son exécution, chaque paramètre est codé comme une variable dans le code de la fonction paramétrée. Ainsi, le code de chaque fonction paramétrée, contenu dans le programme 28, comporte des opérations de lecture de la valeur de chaque paramètre dans une mémoire, avant de pouvoir traiter ce paramètre. Par exemple, la valeur du paramètre est utilisée, à l'intérieur du code générique de la fonction, comme opérande d'une ou plusieurs opérations à réaliser. Il peut s'agir de n'importe quelle opération. Par exemple, ces opérations sont des opérations arithmétiques, booléennes ou de lecture d'une données à une adresse spécifiée par la valeur du paramètre. Le paramètre peut aussi être de nature non fonctionnelle. Par exemple, il contient des informations sur les caractéristiques de la micro-architecture du microprocesseur 10 sur lequel va être exécuté le programme 28.
[0038] Une fonction correspond à au moins un bloc de base. Une fonction n'est pas limitée à un seul bloc de base et peut comporter plusieurs blocs de base dont les exécutions doivent être enchaînées les unes après les autres.
[0039] Par la suite, à titre d'illustration, on considère que le programme 28 comporte le code de trois fonctions génériques paramétrées notées, respectivement, F, G et H. Ces trois fonctions génériques F, G et H sont représentées, sous forme de pseudocode compréhensible par l'homme du métier, respectivement, dans les figures 6 à 8. Ici, la fonction générique F réalise la multiplication de deux matrices A et B et enregistre le résultat dans une matrice R. Les paramètres de la fonction F sont les adresses où débutent les matrices A, B et R et les dimensions de ces matrices.
[0040] Dans le cas particulier décrit ici, pour exécuter le programme 28 sur le microprocesseur 2, la mémoire 6 comporte aussi :
- le code d'un interpréteur 30 de Bytecode, et
- le code d'un gestionnaire 34 du flux d'exécution du programme à exécuter.
[0041] Chacun de ces codes 30 et 34 est, de préférence, écrit dans le langage machine du microprocesseur 10 et donc directement exécutable par ce microprocesseur.
[0042] L'interpréteur 30 est également connu sous le terme de « machine virtuelle » dans le cas particulier du Bytecode Java. L'interpréteur 30 contient un jeu de routines en langage machine associées à chaque instruction contenue dans le jeu d'instructions Bytecode. L'interprétation consiste à exécuter la routine en langage machine correspondant à chaque instruction Bytecode du programme 28.
[0043] Le gestionnaire 34 a pour fonction de gérer le flot d'exécution des programmes exécutés tel que le programme 28. En particulier, comme cela sera décrit plus en détail plus loin, le gestionnaire 34 est capable de diriger vers l'accélérateur 12 l'exécution d'une fonction prédéterminée.
[0044] La mémoire 6 comporte aussi une base de données 36 de configurations et une table 38.
[0045] La figure 2 représente schématiquement l'architecture de la base 36. La base 36 comporte ici plusieurs jeux différents d'instructions de configuration de l'accélérateur 12. Par exemple, ces jeux d'instructions de configuration de l'accélérateur 12 sont des fichiers contenant chacun une représentation binaire d'une configuration de l'accélérateur 12. Un tel jeu d'instructions peut être obtenu en compilant une configuration de l'accélérateur 12 décrite en utilisant, par exemple, le langage VHDL (« VHSIC hardware description langage »). Pour simplifier la figure 2, seuls trois jeux différents d'instructions, notés Jl à J3, sont représentés. Chacun de ces jeux d'instructions peut être chargé dans l'accélérateur 12 pour modifier sa configuration matérielle et ainsi le rendre capable d'exécuter une fonction prédéterminée. Par la suite, on note Fspei, Gspei et Hspei les fonctions prédéterminées réalisées par l'accélérateur 12 lorsqu'il est chargé avec, respectivement, les jeux Jl, J2 et J3. Ici, ces fonctions Fspel, Gspel et Hs ei correspondent, respectivement, aux fonctions génériques F, G et H mais spécialisées avec des valeurs prédéterminées pour leurs paramètres. Par exemple, la fonction Fspei est identique à la fonction F dans le cas particulier où les dimensions des matrices A, B et R sont égales, respectivement, à [6 x 5], [5 x 7] et [6 x 7]. Dans ce texte, le symbole [lx x ly] indique le nombre de lignes (lx) et le nombre de colonnes (ly) de la matrice. La fonction Fs ei est donc identique à la fonction F mais spécialisée avec les valeurs 6, 7 et 5 pour, respectivement, des paramètres MaxLine, MaxColumn et MaxElement de la fonction F représentés sur la figure 6. Le nombre de paramètres dont les valeurs doivent être fournies à la fonction Fspei est donc plus petit que dans le cas de la fonction F. Toutefois, ici, la fonction Fspei admet encore trois paramètres qui sont les adresses des matrices A, B et R. Ainsi, même lorsque la fonction Fs ei est exécutée par l'accélérateur 12, les valeurs de ces trois paramètres restant sont fournies à l'accélérateur 12.
[0046] Ces jeux Jl, J2 et J3 peuvent être chargés dans l'accélérateur 12 par le microprocesseur 10.
[0047] À chaque jeu d'instructions de configuration, la base 36 associe une ou plusieurs signatures préenregistrées différentes. Par exemple, ici, la base 36 associe trois signatures SU, S12 et S13 au jeu Jl, une signature S21 au jeu J2 et quatre signatures S31 à S34 au jeu J3.
[0048] Chacune de ces signatures permet au gestionnaire 34 d'identifier, lors de l'exécution du programme 28, qu'une fonction prédéterminée est actuellement exécutée par le microprocesseur 10. Ici, les signatures SU à S13 permettent d'identifier la fonction Fs ei, la signature S21 permet d'identifier la fonction Gs ei et les signatures S31 à 34 permettent d'identifier la fonction Hs ei.
[0049] Il existe différentes façons de construire de tels signatures. Un premier exemple de réalisation est décrit ci-dessous dans le cas particulier de la signature SU.
[0050] La signature SU (figure 3) comporte au moins une séquence d'identifiants d'opcodes classés dans l'ordre où ces opcodes sont exécutés lorsque la fonction Fs ei est réalisée par le microprocesseur 10. Sur la figure 3, cette séquence est représentée par le symbole « Seqll ». En effet, par analogie à une séquence prédéterminée de bases d'un brin d'ADN, une telle séquence d'identifiants d'opcodes peut être suffisante à elle seule pour identifier sans ambiguïté la fonction Fs ei. En particulier, pour être capable d'identifier sans ambiguïté une fonction prédéterminée, la séquence d'identifiants opcodes n'a pas besoin de contenir les identifiants de tous les opcodes exécutés par le microprocesseur 10 lorsqu'il réalise cette fonction. Au contraire, en général, la séquence d'identifiants d'opcodes contient seulement les identifiants d'opcodes les plus caractéristiques de la fonction prédéterminée et non pas la totalité des identifiants des opcodes exécutés lors de la réalisation de cette fonction prédéterminée.
[0051] Lorsque la séquence d'identifiants d'opcodes n'est pas suffisante à elle seule pour identifier sans ambiguïté la fonction réalisée ou pour raccourcir cette séquence, la signature préenregistrée peut alors comporter en plus une cartographie préenregistrée d'au moins une partie des accès mémoires observés lorsque le microprocesseur 10 exécute cette fonction prédéterminée. Par exemple, ici, la signature SU comporte une cartographie préenregistrée Call. En effet, les positions relatives, c'est-à-dire les uns par rapport aux autres, des différents mots-machine accédés en mémoire 6 lors de la réalisation de la fonction par le microprocesseur 10 est aussi une caractéristique spécifique de la fonction prédéterminée. Elle peut donc aider à identifier sans ambiguïté cette fonction parmi d'autres fonctions possibles. Cette caractéristique est indépendante de l'ordre dans lequel les opcodes de la fonction prédéterminée sont exécutés par le microprocesseur 10.
[0052] Par « mot-machine », on désigne un groupe de taille fixe de cellules mémoires élémentaires manipulé en tant qu'une seule entité par les opcodes du langage- machine du microprocesseur 10. Typiquement, la taille d'un mot-machine est donc souvent égale à 8, 16, 32 ou 64 bits.
[0053] Chaque cartographie comporte au moins une description de l'agencement dans la mémoire d'un ensemble de N mots-machine, où N est un nombre entier supérieur ou égale à 4, 10 ou 20. Ici, cette description définit les positions relatives, c'est-à-dire les uns par rapport aux autres, des N mots-machine de cet ensemble. Les N mots-machine sélectionnés pour faire partie du même ensemble peuvent être :
- des mots-machine uniquement accédés en lecture lors de l'exécution de la fonction,
- des mots-machine uniquement accédés en écriture lors de l'exécution de la fonction, ou
- une combinaison des deux possibilités précédentes.
[0054] A titre d'illustration, la cartographie Call comporte :
- une description Enll qui définit les positions relatives des 30 mots-machine qui forment la matrice A,
- une description Enl2 qui définit les positions relatives des 35 mots-machine qui forment la matrice B, et - une description Enl3 qui définit les positions relatives des 42 mots-machine qui forment la matrice R.
[0055] Ici, les descriptions Enll, Enl2 et Enl3 sont indépendantes les unes des autres. Autrement dit, toutes modifications de l'une de ces descriptions n'a aucune influence sur les autres descriptions. Dans le cas de la cartographie Call, les descriptions Enll, Enl2 et Enl3 ne précisent pas qu'elles sont les opcodes exécutés avant ou après l'accès à chacun de ces mots-machine. Par exemple, la description Enll définit un agencement de 35 mots-machine contigus les uns aux autres et formant une matrice de six lignes et cinq colonnes,
[0056] La figure 4 représente un autre mode de réalisation possible d'une signature préenregistrée. Cet autre mode de réalisation est décrit dans le cas particulier de la signature S12.
[0057] Dans cet exemple, la signature S12 comporte une cartographie Cal2 contenant une description ER de l'agencement des 42 mots-machine formant la matrice R. Sur ce point, la description ER est identique à la description Enl3. Toutefois, en plus, la description ER associe, à chaque mot-machine de la matrice R, une séquence d'identifiants d'opcodes exécutés juste avant ou après l'écriture dans ce mot-machine. Par exemple, dans le cas de la fonction Fspei, chaque mot-machine de l'ensemble ER est associé à la séquence Seql2 d'identifiants d'opcodes suivantes {IdM ; IdA} exécutée avant chaque écriture dans un mot-machine de la matrice R, où
- IdM est l'identifiant de l'opcode qui, lorsqu'il est exécuté par le microprocesseur 10, réalise une multiplication, et
- IdA est l'identifiant de l'opcode qui, lorsqu'il est exécuté par le microprocesseur 10, réalise une addition.
[0058] En effet, comme on le comprendra à la lecture du pseudo-code représenté sur la figure 6, chaque écriture dans un mot-machine de la matrice R, est précédée d'une multiplication et d'une addition.
[0059] De plus, dans ce cas particulier de la signature S12, la séquence Seql2 remplace la séquence Seqll.
[0060] Une même fonction prédéterminée peut être programmée et compilée de différentes façons. Il existe donc généralement plusieurs variantes d'implémentation possibles pour réaliser la même fonction. Par exemple, au lieu d'utiliser l'algorithme de la figure 6 pour réaliser une multiplication de matrices, il est aussi possible d'utiliser l'algorithme connu sous le terme anglais de « tiled matrix multiply algorithm » et décrit dans l'article « Matrix multiplication algorithm » du site https://en.wikipedia.org. Chaque variante d'implémentation peut correspondre à une signature différente construite selon l'un des modes de réalisation décrit ici. Par conséquent, de préférence, le même jeu Jl est associé à plusieurs signatures différentes correspondant chacune à une variante respective d'implémentation de la même fonction Fspei. Sur la figure 2, c'est aussi le cas pour le jeux J3.
[0061] La figure 5 représente schématiquement un exemple d'architecture possible pour la table 38. La table 38 a pour fonction d'associer l'adresse, dans le programme 28 où débute l'exécution d'une fonction prédéterminée, au jeu d'instructions de configuration qui, lorsqu'il est chargé dans l'accélérateur 12, permet à cet accélérateur d'exécuter cette fonction. Ici, par exemple, la table 38 contient l'adresse @Fspei où débute l'exécution de la fonction F dans le programme 28. L'adresse @Fspei est typiquement égale à l'adresse de branchement du premier bloc de base de la fonction F dans le programme 28. L'adresse @Fspei est chargée dans le compteur ordinal du microprocesseur 10, par exemple, suite à l'exécution d'une instruction de branchement. L'instruction de branchement peut être un saut conditionnel ou non ou un appel à une fonction.
[0062] La table 38 associe à cette adresse @Fspei, les valeurs des différents paramètres de la fonction F avec lesquels elle doit être spécialisée pour que son exécution puisse être transférée vers l'accélérateur 12. Ainsi, dans l'exemple simplifié représenté sur la figure 5, la table 38 associe à l'adresse @Fs ei , les valeurs 6, 7 et 5 respectivement des paramètres MaxLine, MaxColumn, and MaxElement.
[0063] La figure 6 représente sous la forme de pseudo-code compréhensible par l'homme du métier la fonction générique F qui peut être spécialisée pour obtenir la fonction Fspel. Ici, cette fonction F est la fonction qui multiplie les matrices A et B, respectivement, de dimensions [MaxLine ; MaxElement] et [MaxElement ; MaxColumn] et enregistre le résultat dans la matrice R de dimension [MaxLine ; MaxColumn]. Les paramètres de cette fonction générique F sont ici les adresses @A, @B et @R des premiers mots-machine des matrices, respectivement A, B et R. Les paramètres de cette fonction générique F sont également les dimensions de ces matrices désignées ici par les termes MaxLine, MaxColumn et MaxElement. La fonction Fs ei correspond à la fonction F dans le cas particulier où les paramètres MaxLine, MaxColumn et MaxElement sont respectivement égaux à 6, 7 et 5. On suppose ici que ces paramètres, et notamment les dimensions des matrices A, B et R, sont uniquement connus au moment de l'exécution du programme 28. Dans le pseudo-code représenté dans la figure 6, le symbole « += » désigne une opération d'addition du résultat de la multiplication A[line][elmt] x B[elmt][column] dans la cellule R[line][column] de la matrice R.
[0064] Lors de l'exécution du programme 28, cette fonction F est appelée avec des valeurs connues pour chacun de ses paramètres.
[0065] La figure 7 représente sous une forme de pseudo-code compréhensible par l'homme du métier la fonction générique G. Cette fonction G est paramétrée par trois paramètres, à savoir @P, Lmax et Cmax. Le paramètre @P est l'adresse du premier pixel d'une image enregistrée sous la forme d'une matrice de pixels de Lmax lignes et de Cmax colonnes. Dans cette matrice, chaque cellule P[line][column] correspond à un mot-machine de 32 bits. Les 8 premiers bits de ce mot-machine code l'intensité du rouge dans l'espace de couleur RGB (Red, Green, Blue). Les 8 bits suivants de ce même mot-machine code l'intensité du vert dans le même espace. Les 8 bits suivants de ce mot-machine codent le bleu toujours dans le même espace et les 8 derniers bits du mot-machine code la transparence de la couleur.
[0066] Chacun de ces codes couleurs ainsi que la transparence doit être compris entre 0 et maxval par exemple. Ainsi, un traitement classique de cette image consiste à s'assurer que la valeur de chaque code couleur et du code de transparence de chaque cellule de la matrice est bien compris entre 0 et maxval. Si ce n'est pas le cas, alors la valeur actuelle des 8 bits concernés est remplacée par la valeur 0 ou maxval. La fonction générique G représentée sur la figure 7 réalise ce traitement de l'image. Dans cette figure, la fonction Extract(P[line][column], i) renvoie la valeur de la plage de 8 bits située à la position i. Lors que i = 0, cette fonction renvoie la valeur des 8 premiers bits du pixel P[line][column], lorsque i = 1, la fonction Extract renvoie la valeur des 8 bits suivants du pixel P[line][column] et ainsi de suite jusqu'à i = 3. La fonction Write(P[line][column] ; i ; r) écrit la valeur r dans la plage de 8 bits située à la position i.
[0067] Lorsque la fonction G est spécialisée avec les valeurs 10, 10 et 255 pour les paramètres, respectivement, Lmax, Cmax et maxval, elle correspond à la fonction Gspei.
[0068] La signature S21 permet d'identifier l'exécution de la fonction Gspei. Par exemple, pour cela, la signature S21 est identique à la signature Sll sauf que la séquence Seqll est remplacée par une séquence Seq21 et la cartographie Call est remplacée par une cartographie Ca21.
[0069] La séquence Seq21 comporte une séquence primaire Seq211. La séquence Seq211 est la suivante {IdCO ; ldC255}, où :
- IdCO est l'identifiant de l'opcode de comparaison à 0,
- ldC255 est l'identifiant de l'opcode de comparaison à 255.
[0070] La séquence primaire Seq211 est répétée quatre fois d'affilée pour obtenir une séquence secondaire Seq212 et cette séquence Seq212 est répétée cent fois d'affilée pour obtenir la séquence Seq21.
[0071] La cartographie Ca21 comporte une description qui définit les positions relatives des 100 mots-machine de la matrice qui contient les pixels de l'image traitée. Dans une variante simplifiée, la cartographie Ca21 peut être omise car, ici, la séquence Seq21 est suffisante à elle-seul pour identifier sans ambiguïté la fonction
Gspel-
[0072] On notera que la signature S21 aurait aussi pu être construite de façon similaire à ce qui a été décrit pour la signature S12. En effet, la fonction Gspei se caractérise également par le fait qu'après chaque accès en lecture à un pixel de l'image, les opcodes identifiés par la séquence Seq212 sont exécutés. Ainsi, une variante possible de la signature S21 est construite en associant la séquence Seq212 à chacun des 100 mots-machine dont les positions relatives sont définies par la cartographie Ca21.
[0073] La figure 8 représente le code, en langage C, de la fonction générique H qui calcule la différence entre des blocs de pixels de deux images différentes. Ce code provient du projet VideoLAN et plus précisément du fichier « pixel. c » téléchargeable gratuitement depuis le site Internet www.videolan.org. Le code de cette fonction H a été écrit par Loren Merritt (lorenm@u.washington.edu), Laurent Aimar (fenrir@via.ecp.fr) et Fiona Glaser (fiona@x264.com). Étant donné que cette fonction H est bien connue, celle-ci n'est pas décrite ici en détail. On observera seulement que la fonction H admet plusieurs paramètres dont notamment :
- la largeur Ix du bloc,
- la hauteur ly du bloc,
- l'adresse *picl du bloc de pixels dans la première image,
- l'adresse *pic2 du bloc de pixels dans la deuxième image,
- la distance i_stride-pixl entre deux lignes consécutives du bloc dans la première image,
- la distance i_stride_pix 2 entre deux lignes consécutives du bloc dans la deuxième image.
[0074] La fonction Hspei correspond à la fonction H spécialisée avec des valeurs particulières pour la largeur Ix et la hauteur ly du bloc.
[0075] La fonction Hs ei se caractérise notamment, après chaque accès en lecture à un pixel de chacune des première et deuxième images, par l'exécution dans l'ordre :
- d'un opcode qui calcule une différence (ligne 13 du code représenté),
- d'un opcode qui calcule une valeur absolue (ligne 13 du code représenté),
- d'un opcode qui calcule une somme (ligne 13 du code représenté),
- par la réitération des calculs précédents Ix x ly, et
- la lecture en alternance d'un pixel dans la première image, puis d'un pixel dans la deuxième image.
[0076] À partir de ces observations, et des enseignements donnés précédemment en regard des signatures SU et S12, il est possible de construire plusieurs signatures pour identifier cette fonction Hspei. Ici, les quatre signatures S31 à S34 sont construites pour cela.
[0077] Le fonctionnement de l'appareil 2 va être décrit en référence au procédé de la figure 9.
[0078] Le procédé débute par une étape 100, lors de laquelle la base 36 est construite. Lors de cette étape, un programmeur développe et conçoit les différents jeux d'instructions de configuration et notamment les jeux Jl à J3.
[0079] Les jeux d'instructions enregistrés dans la base 36 peuvent être choisis en fonction des connaissances que l'on a sur les fonctions exécutées par le programme 28. Ils peuvent aussi être choisis sur la base d'autres critères tels que des connaissances statistiques sur l'intérêt d'implémenter tel ou tel jeu d'instructions dans un calculateur pour accélérer l'exécution d'un programme qu'on ne connaît pas à l'avance. Ainsi, le choix des jeux d'instructions peut être fait indépendamment du ou des programmes qui seront exécutés par le calculateur 4.
[0080] Pour chaque jeu d'instructions enregistré dans la base 36, le programmeur construit une ou plusieurs signatures aptes à identifier la fonction prédéterminée, correspondant à ce jeu d'instructions, lorsqu'elle est exécutée par le microprocesseur 10. Chacune de ces signatures construites est enregistrée et associée dans la base 36 au jeu d'instructions correspondant.
[0081] Typiquement, à ce stade, le programmeur construit une signature pour chaque variante possible d'implémentation de la fonction prédéterminée ou au moins pour les variantes d'implémentation habituelles de cette fonction prédéterminée. En effet, comme déjà indiqué précédemment, une même fonction peut être implémentée de différentes façons dans un programme de sorte que la présence de différentes signatures permet d'augmenter la probabilité que l'exécution de cette fonction prédéterminée soit correctement identifiée. Lors de cette étape, le programmeur construit notamment les différentes signatures représentées sur la figure 2.
[0082] Lors d'une étape 102, la base 36 construite est fournie au calculateur 4. Par exemple, elle est enregistrée à cet effet dans la mémoire 6.
[0083] Ensuite, lors d'une phase 110, l'exécution de programmes par le calculateur 4 débute. Cette phase 110 est décrite par la suite dans le cas particulier du programme 28 et de la fonction Fs ei. Toutefois, ce qui est décrit dans ce cas particulier se généralise sans difficulté à tout autre programme et toute autre fonction prédéterminée. De plus, initialement, par exemple la table 38 est vide et aucune fonction n'est configurée dans l'accélérateur 12.
[0084] Lors d'une étape 112, le programme 28 est chargé dans la mémoire 6.
[0085] Puis, lors d'une étape 116, le microprocesseur 10 commence par exécuter l'interpréteur 30. L'interprétation consiste à exécuter la routine en langage machine correspondant à chaque instruction Bytecode du programme 28 en les balayant les unes après les autres. Lors de ces réitérations de l'étape 116, le microprocesseur 10 obtient d'abord les valeurs de chaque paramètre d'une fonction paramétrée avant de l'appeler avec les valeurs ainsi obtenues. L'appel de la fonction se matérialise par un branchement vers une adresse de branchement où est enregistrée la première instruction du code générique de cette fonction.
[0086] Dès qu'un branchement vers l'adresse de branchement d'une fonction doit être exécuté, lors d'une étape 118, le gestionnaire 34 est exécuté par le microprocesseur 10. L'exécution d'un tel branchement correspond à l'appel d'une fonction avec les valeurs des paramètres obtenues lors de l'exécution de l'étape 116.
[0087] Lors de l'étape 118, le gestionnaire 34 vérifie si la fonction appelée correspond à la fonction Fspei configurée dans l'accélérateur 12. Pour cela, par exemple, le gestionnaire 34 vérifie d'abord si l'adresse de branchement vers laquelle est dirigée l'exécution du code du programme 28 correspond à l'adresse @Fs ei enregistrée dans la table 38. Dans l'affirmative, le gestionnaire 34 vérifie également si les valeurs des paramètres avec lesquelles la fonction F est appelée correspondent aux valeurs enregistrées pour ces paramètres dans la deuxième colonne de la table 38. Si au moins l'une de ces deux vérifications n'est pas réalisée avec succès, alors le gestionnaire 34 ne déclenche pas l'exécution de la fonction Fspei par l'accélérateur 12. On notera que puisque la table 38 est initialement vide, lors de la première exécution de la fonction Fspei , ces deux vérifications échouent et le procédé se poursuit donc par l'étape 124 de collecte de la signature de cette fonction décrite plus loin.
[0088] Dans le cas contraire, c'est-à-dire s'il s'agit de la deuxième exécution ou d'une exécution suivante de la fonction Fspei et si ces deux vérifications sont réalisées avec succès, alors le gestionnaire 34 détecte que l'exécution par l'accélérateur 12 de la fonction Fs ei doit être déclenchée. Dans ce dernier cas, ici, l'accélérateur 12 est déjà actuellement configuré pour exécuter cette fonction Fs ei. Le gestionnaire 34 procède alors à l'exécution d'une étape 120. Ainsi, lors de l'étape 118, lorsque la fonction Fs ei doit de nouveau être exécutée, le gestionnaire 34 est donc capable de déclencher l'exécution de la fonction Fspei par l'accélérateur 12 sans pour cela avoir nécessairement à réitérer l'étape 124.
[0089] Lors de l'étape 120, le microprocesseur 10 déclenche l'exécution de la fonction Fs ei par l'accélérateur 12. Cette fonction Fs ei n'est alors pas exécutée par le microprocesseur 10 mais par l'accélérateur 12. Dès lors, ici, tant que l'accélérateur 12 n'a pas fini d'exécuter la fonction Fspei, l'exécution de l'étape 116 est suspendue.
[0090] On notera que lorsque l'étape 120 est exécutée, il n'est pas nécessaire d'interpréter ou de compiler le code générique de la fonction F, ce qui constitue déjà un gain de temps substantiel. De plus, comme expliqué précédemment, l'accélérateur 12 exécute plus rapidement la fonction Fs ei que le microprocesseur 10. Ainsi, l'exécution de la fonction Fs ei est substantiellement accélérée. À la fin de l'exécution de la fonction Fspei par l'accélérateur 12, l'exécution de l'étape 116 reprend après les instructions d'appel de la fonction Fspei.
[0091] Le basculement de l'exécution d'une fonction vers un accélérateur matériel puis le retour vers le programme ayant appelé cette fonction est par exemple décrit dans l'article suivant : Pablo De Oliveira Castro, Chadi Akel, Eric Petit, Mihail Popov, and William Jalby. CERE: « LLVM-based Codelet Extractor and REplayer for piecewise benchmarking and optimization ». ACM Transactions on Architecture and Code Optimization (TACO) , 12(1):6, 2015.
[0092] Si à l'issue de l'étape 118, le gestionnaire 34 n'a pas détecté le déclenchement de l'exécution de la fonction Fs ei , il procède à l'étape 124 de collecte d'une signature de la fonction appelée. En parallèle, la fonction appelée est exécutée par le microprocesseur 10. Pour cela, l'exécution de l'étape 116 se poursuit en parallèle de l'étape 124.
[0093] Lors de l'étape 124, le gestionnaire 34 collecte la signature de la fonction appelée. A cet effet, ici, pendant toute la durée de l'exécution de la fonction appelée, il collecte dans l'ordre d'exécution :
- les identifiants des opcodes exécutés par le microprocesseur 10 pour obtenir une séquence collectée d'identifiants d'opcodes exécutés, et
- les adresses des mots-machine de la mémoire 6 lus ou écrits au cours de l'exécution de cette fonction appelée pour obtenir une séquence collectée d'adresses.
[0094] Lors de cette étape, si la base 36 comporte des signatures préenregistrées comme la signature S12, alors, la séquence d'identifiants d'opcodes exécutés immédiatement avant et après un accès à la mémoire est également collectée. Par « séquence d'identifiants d'opcodes exécutés immédiatement avant un accès mémoire », on désigne une séquence ordonnée d'identifiants d'opcodes exécutés uniquement entre le précédent accès à la mémoire et cet accès à la mémoire. Par « séquence d'identifiants d'opcodes exécutés immédiatement après un accès mémoire », on désigne une séquence ordonnée d'identifiants d'opcodes exécutés uniquement entre cet accès à la mémoire et le suivant. Par exemple, dans un mode de réalisation, lors de l'étape 124, le gestionnaire 34 relève tous les identifiants d'opcodes exécutés pendant toute la durée de l'exécution de la fonction appelée. De plus, pour chaque identifiant d'opcodes correspondant à un opcode qui, lorsqu'il est exécuté par le microprocesseur 10, déclenche un accès à la mémoire 6, le gestionnaire 34 collecte en plus l'adresse du mot-machine lu ou écrit et l'associe à cet identifiant d'opcodes dans la séquence d'identifiants d'opcodes collectée. À partir d'une telle séquence, il est donc possible de connaître, quels sont les opcodes exécutés immédiatement avant et immédiatement après un accès à la mémoire 6. Il est également possible de connaître le type d'accès à la mémoire 6 parmi les deux types d'accès possibles, c'est-à-dire un accès en lecture et un accès en écriture.
[0095] Au fur et à mesure que la signature est collectée lors de l'étape 124 ou lorsque l'exécution de la fonction appelée par le microprocesseur 10 est terminée, lors d'une étape 128, le gestionnaire 34 compare la signature collectée à chacune des signatures préenregistrées dans la base 36.
[0096] Selon le type de signature préenregistrée, cette comparaison est réalisée de différentes manières.
[0097] Si la signature préenregistrée comporte uniquement une séquence préenregistrée telle que la séquence Seqll de la figure 3 et aucune cartographie préenregistrée des accès mémoires, alors le gestionnaire 34 essaie de trouver dans la séquence collectée d'identifiants d'opcodes exécutés, une séquence d'identifiants identique à la séquence préenregistrée. Une séquence collectée est identique à une séquence préenregistrée si elle comporte les mêmes identifiants dans le même ordre. Selon les modes de réalisation mis en œuvre, pour qu'il y ait identité entre la séquence collectée et la séquence préenregistrée, il est aussi possible d'imposer que les identifiants de la séquence collectée soit tous immédiatement consécutifs, c'est-à- dire qu'ils ne soient pas séparés les uns des autres par un ou plusieurs identifiants qui n'appartiennent pas à la séquence préenregistrée. Dans l'affirmative, le gestionnaire 34 en déduit que la signature collectée correspond à la signature préenregistrée dans la base 36. Dans le cas contraire, il en déduit que la signature collectée ne correspond pas à cette signature préenregistrée.
[0098] Si la signature préenregistrée comporte en plus une cartographie telle que la cartographie Call, pour chaque description Enll à Enl3, le gestionnaire 34 recherche dans la séquence collectée d'adresses un agencement de mots-machine qui correspond à cette description. Ici, le gestionnaire 34 considère qu'un agencement de mots-machine correspond à une description contenue dans une cartographie préenregistrée si cet agencement est identique à celui défini par cette description.
[0099] Seulement si le gestionnaire 34 trouve dans la signature collectée :
- une séquence d'identifiants d'opcodes identique à la séquence d'identifiants d'opcodes enregistrée dans la signature préenregistrée, et
- pour chaque description d'un agencement de mots-machine contenue dans la cartographie de cette signature préenregistrée, un agencement correspondant de mots-machine dans la séquence collectée d'adresses,
alors, le gestionnaire 34 en déduit que la signature collectée correspond à la signature préenregistrée.
[00100] Si la signature préenregistrée est construite comme décrit dans le cas particulier de la signature S12 :
1) le gestionnaire 34 recherche, dans la séquence collectée d'adresses, un agencement de mots-machine lus ou écrits qui correspond à la description ER, puis
2) le gestionnaire 34 vérifie que l'opération d'écriture ou de lecture de chacun des mots-machine de cet agencement a bien été immédiatement précédée ou suivie de la séquence d'identifiants d'opcodes associée à ce mot-machine par la description ER.
[00101] La vérification 2) ci-dessus est réalisée à partir de la séquence d'identifiants d'opcodes collectée.
[00102] La comparaison de la signature collectée à la signature préenregistrée peut aussi être réalisée en parallèle de l'exécution de l'étape 124. Ceci est illustré dans le cas particulier de la signature S12. Avant le début de l'étape 124, le gestionnaire 34 construit une grille 130 (figure 10) dans laquelle chaque case est disposée par rapport aux autres cases comme défini par la description ER. Ici, la grille 130 est donc une matrice rectangulaire de six lignes et sept colonnes. On considère que l'adresse de la case située à l'angle supérieur gauche de cette grille 130 correspond à l'adresse @R de la matrice R passée en tant que paramètre à la fonction appelée. Ainsi, il existe une correspondance entre l'adresse des mots- machine écrits dans la mémoire 6 et chaque case de cette grille 130.
[00103] Lors de l'exécution de l'étape 124, chaque fois que la fonction appelée écrit un mot-machine correspondant à une case de cette grille dans la mémoire 6, lors de l'étape 128, le gestionnaire 34 vérifie si cette opération d'écriture a été immédiatement précédée, dans l'ordre, par une opération de multiplication puis une opération d'addition. Si c'est le cas, le gestionnaire 34 marque cette case. Dans le cas contraire, le gestionnaire 34 ne marque pas cette case. Sur la figure 30, les cases déjà marquées dans la grille 130 sont grisées, tandis que les cases non encore marquées sont blanches.
[00104] Si à la fin de l'exécution de l'étape 124, toutes les cases de la grille 130 sont marquées, alors le gestionnaire 34 en déduit que la signature collectée correspond à la signature S12. Dans le cas contraire, il en déduit une absence de correspondance avec la signature S12.
[00105] Si à l'issue de l'exécution de l'étape 128, le gestionnaire 34 a déterminé que la signature collectée ne correspond à aucune des signatures préenregistrées dans la base 36, alors l'exécution du programme 28 se poursuit et le procédé retourne à l'étape 116.
[00106] Si au contraire, à l'issue de l'exécution de l'étape 128, le gestionnaire 34 a déterminé que la signature collectée correspond à l'une des signatures préenregistrées dans la base 36, alors, lors d'une étape 132, le gestionnaire 130 charge le jeu d'instructions associé à cette signature préenregistrée dans l'accélérateur 12. Ensuite, il enregistre dans la table 38, à la place des données déjà présentes dans cette table :
- l'adresse de branchement à laquelle débute l'exécution de la fonction identifiée, et
- les valeurs des paramètres avec lesquels cette fonction doit être spécialisée pour correspondre à la fonction exécutée par l'accélérateur 12.
En faisant cela, le gestionnaire 34 associe cette adresse de branchement à l'accélérateur 12 et donc au jeu d'instructions de configuration chargé préalablement dans l'accélérateur 12 et qui permet de réaliser plus rapidement la fonction identifiée.
[00107] Après avoir réalisé ces opérations, l'exécution du programme 28 se poursuit et le procédé retourne à l'étape 116.
[00108] Dès lors, comme expliqué précédemment, si la fonction, par exemple la fonction Fs ei, doit de nouveau à être exécutée, celle-ci sera alors exécutée par l'accélérateur 12 et non pas par le microprocesseur 10.
[00109] La figure 11 représente un appareil électronique 150 identique à l'appareil électronique 2, sauf que :
- l'accélérateur 12 est remplacé par un coprocesseur 152, et
- la base 36 est remplacée par une base 154.
[00110] Le coprocesseur 152 est spécialement conçu pour exécuter un type particulier de fonction plus rapidement que ce qui peut être fait avec le microprocesseur 10. Par exemple, le coprocesseur 152 peut-être :
- un coprocesseur connu sous l'acronyme DSP (« Digital Signal Processing ») spécialement conçu pour exécuter rapidement des fonctions de traitement d'un signal,
- un coprocesseur connu sous l'acronyme GPU (« Graphical Processing Unit ») spécialement conçu pour exécuter rapidement des fonctions de traitement d'une image,
- un coprocesseur connu sous le terme « calculateur quantique » spécialement conçu pour exécuter rapidement des fonctions nécessitant peu d'entrées, ou
- un coprocesseur de sécurité spécialement conçu pour exécuter rapidement des fonctions de chiffrement et de déchiffrement.
[00111] La base de données 154 est identique à la base 36, sauf que chaque jeu d'instructions est un code-machine d'une fonction prédéterminée exécutable directement par le coprocesseur 152. Ce code machine peut être optimisé pour son exécution par le coprocesseur 152. Dans ce cas, le code machine exécuté par le coprocesseur 152 est différent du code machine de la même fonction exécuté par le microprocesseur 10. Le code machine de la fonction exécutée par le coprocesseur 152 peut aussi être identique au code machine de la même fonction exécutée par le microprocesseur 10. Dans ce dernier cas, le fait que ce code machine s'exécute plus rapidement sur le coprocesseur 152 que sur le microprocesseur 10 s'explique par des différences entres les architectures matériels du coprocesseur 152 et du microprocesseur 10.
[00112] Le fonctionnement de l'appareil 150 se déduit des explications données en référence à la figure 9. Toutefois, dans le cas de l'appareil 150, lors de l'étape 132, à chaque fois qu'une nouvelle fonction prédéterminée est identifiée, une ligne supplémentaire est ajoutée dans la table 38. Cette ligne supplémentaire comporte, en plus de l'adresse de branchement où débute l'exécution de la fonction identifiée et des valeurs des paramètres de cette fonction identifiée, un lien vers le jeu d'instructions de la base 36 à exécuter par le coprocesseur 152. Le jeu d'instructions à exécuter est celui associé à la signature préenregistrée reconnue. Ainsi, typiquement, la table 38 comporte plusieurs lignes. Lors de l'étape 120, c'est le code- machine associé par la table 38 à l'adresse de la fonction appelée qui est exécuté par le coprocesseur 152 pour réaliser cette fonction.
[00113] La figure 12 représente un appareil électronique 160, identique à l'appareil 150, sauf que l'accélérateur 12 est omis et que la base de données 36 est remplacée par une base de données 162.
[00114] La base 162 est par exemple identique à la base 154, sauf que chaque jeu d'instructions est un code-machine d'une fonction prédéterminé directement exécutable par le microprocesseur 10. [00115] Le fonctionnement de l'appareil 160 se déduit des explications données en référence à la figure 11. Toutefois, dans le cas de l'appareil 160, lors de l'étape 120, le code-machine associé, par la table 38, à l'adresse de branchement de la fonction appelée est exécuté par le microprocesseur 10 pour réaliser cette fonction. Ainsi, l'exécution du programme 28 est rendue plus rapide car, dans ce cas, il n'est pas nécessaire d'interpréter systématique le Bytecode de la fonction prédéterminée appelée.
[00116] Les variantes suivantes des modes de réalisation décrits ici sont possibles :
[00117] Variantes de la cartographie préenregistrée:
[00118] Dans une variante, la description d'un agencement de mots-machine associe à un seul ou seulement à quelques uns de ces mots-machine, une séquence d'identifiants d'opcodes exécutés immédiatement après l'écriture ou la lecture d'une donnée dans ce mot-machine. Par exemple, cette séquence d'identifiants d'opcodes identifie les opérations réalisées sur la donnée immédiatement après sa lecture depuis ce mot-machine.
[00119] Dans une autre variante, la description d'un agencement de mots- machine associe à au moins un de ces mots-machines une séquence d'identifiants d'opcodes exécutés contenant à la fois des identifiants d'opcodes exécutés immédiatement avant et après la lecture ou l'écriture dans ce mot-machine.
[00120] Les séquences d'identifiants d'opcodes associées aux mots-machine par la description de l'agencement de ces mots-machine en mémoire, peuvent être différentes les unes des autres. Ces séquences d'identifiants d'opcodes peuvent également différer les unes des autres selon le type d'accès au mot-machine. Par exemple, la séquence d'identifiants associée au mot-machine lorsque l'accès à ce mot-machine est un accès en écriture, n'est pas la même que la séquence d'identifiants associée à ce même mot-machine lorsque l'accès à ce même mot- machine est un accès en lecture.
[00121] Dans une autre variante, seuls certains mots-machine d'une description d'un agencement de mots-machine sont associés à des séquences d'identifiants d'opcodes et d'autres mots-machine de cette même description sont associés à aucune séquence d'identifiants d'opcodes. Lorsqu'un mot-machine est associé à aucune séquence d'identifiants d'opcodes, cela signifie que les opcodes exécutés immédiatement avant ou après l'écriture ou la lecture dans ce mot-machine ne sont pas utilisés pour identifier la fonction lors de son exécution par le microprocesseur 10.
[00122] Comme déjà illustré précédemment, la signature préenregistrée d'une fonction ne comporte pas nécessairement une cartographie préenregistrée.
[00123] La description d'un agencement de mots-machine n'est pas limitée au cas où cet agencement correspond à une matrice dans laquelle les mots-machine sont disposés en lignes et en colonnes. La description peut définir des agencements quelconque de mots-machine en mémoire. Par exemple, une description peut définir un agencement de N mots-machine dans lequel les mots-machine sont séparés les uns des aux autres par un intervalle régulier ou non mais connu à l'avance. Dans le cas de la fonction Fs ei, la cartographie préenregistrée peut comporter une descriptions définissant en plus les positions relatives, les unes par rapport aux autres, des matrices A, B et R.
[00124] Une même cartographie préenregistrée peut comporter des descriptions de plusieurs agencements différents de mots-machine.
[00125] Dans un mode de réalisation simplifié, la base 36 comporte un seul jeu d'instructions.
[00126] Le nombre de signatures associées, par la base 36, à un même jeu d'instructions peut être plus grand que celui illustré dans les exemples précédents. Par exemple, le nombre de signatures préenregistrées associées à un même jeu d'instructions peut être supérieur à 5, 10 ou 20.
[00127] La base 36 peut aussi comporter plusieurs jeux d'instructions différents qui correspondent tous à la même fonction générique mais spécialisée avec différentes valeurs pour ses paramètres.
[00128] Variantes du calculateur électronique :
[00129] D'autres modes de réalisation de l'accélérateur matériel sont possibles. Par exemple, dans un mode de réalisation particulier, l'accélérateur matériel est un bloc matériel connu sous le terme anglais de « IP MATERIAL ». Ce bloc matériel est préconfiguré pour exécuter une fonction prédéterminée paramétrée. Ainsi, dans ce cas, le jeu d'instructions charge dans le bloc matériel défini uniquement les valeurs des paramètres de cette fonction spécifique. Par exemple, de tels blocs matériels sont connus pour la réalisation de transformées de Fourier.
[00130] Dans un autre mode de réalisation, plusieurs fonctions différentes peuvent être simultanément configurées dans l'accélérateur 12. Par exemple, à cet effet, l'accélérateur 12 est partitionné en plusieurs régions configurées indépendamment les unes des autres, de sorte que chacune de ces régions est capable d'exécuter une fonction prédéterminée particulière. Dans ce cas, par exemple, la table 38 comporte plusieurs adresses de branchement correspondant chacune à l'une des fonctions actuellement configurées dans l'accélérateur 12. De plus, par exemple associées à chacune de ces adresses de branchement, la table 38 comporte des instructions supplémentaires pour activer seulement la région de l'accélérateur 12 qui réalise la fonction souhaitée. Ainsi, dans ce cas, la table 38 peut comporter plusieurs lignes, même lorsque le calculateur 4 utilise un accélérateur matériel.
[00131] Variantes du procédé :
[00132] Dans un mode de réalisation simplifiée, les fonctions prédéterminées, dont les exécutions doivent être accélérées, sont uniquement des fonctions spécialisées lors du développement du programme ou lors de la compilation de ce programme. Dans ce cas, lors de l'exécution du programme, ces fonctions sont toujours exécutées avec les mêmes valeurs des paramètres. La table 38 peut alors être simplifiée en supprimant la deuxième colonne. De même, il n'est plus nécessaire de relever la valeur des différents paramètres de cette fonction pour décider si l'étape 120 doit être ou non exécutée.
[00133] Dans un mode de réalisation particulier, l'accélérateur matériel est capable d'exécuter une fonction générique et non pas une fonction spécialisée. Dans ce cas, les valeurs de tous les paramètres de la fonction générique sont transmises à l'accélérateur 12 au début de l'étape 120 pour qu'il puisse correctement exécuter cette fonction. De façon similaire, dans les modes de réalisations des figures 11 et 12, le code machine associé par la table 38 à une adresse de branchement peut être le code machine d'une fonction générique et non pas d'une fonction spécialisée.
[00134] La configuration de l'accélérateur 12 peut aussi être réalisée à d'autres moments que lors de l'exécution de l'étape 132. Par exemple, en variante, la configuration de l'accélérateur 132 est réalisée au début de l'étape 120.
[00135] Ce qui a été décrit ici fonctionne aussi dans le cas où le programme 28 est directement écrit dans un langage machine exécutable par le microprocesseur 10. Dans ce dernier cas, le programme 28 n'a pas besoin d'être interprété. L'interpréteur 30 peut donc être omis dans ce type de situation. Ce mode de réalisation conserve un intérêt surtout dans le cas des appareils 2 et 150.
[00136] Dans les exemples précédents, l'étape 118 a été décrit comme étant déclenchée par un appel à une fonction. Toutefois, comme indiqué, la fonction, dont l'exécution peut être accélérée, n'est pas nécessairement une fonction appelée par une instruction d'appel dans le programme 28. La fonction qui peut être accélérée peut aussi être un bloc de base du flot d'instructions du programme. Dans ce cas, la détection de cette fonction est par exemple déclenchée et initialisée à chaque fois qu'une instruction de branchement vers un nouveau bloc de base est exécutée.
[00137] L'étape 128 peut être réalisée différemment. Par exemple, pour déterminer si la signature collectée correspond à la signature préenregistrée, il peut être toléré une marge d'erreur et l'on n'est pas obligé de se limiter à une identité entre ces deux signatures. Par exemple, en variante, un taux de corrélation entre la signature collectée et la signature préenregistrée est calculé. Si ce taux de corrélation dépasse un seuil prédéterminé, alors le gestionnaire 34 en déduit que les signatures collectée et préenregistrée correspondent. Ce seuil peut être inférieur à la valeur du taux de corrélation qui est obtenue quand la signature collectée est identique à la signature préenregistrée. Ainsi, en variante, le gestionnaire 34 peut considérer que la séquence collectée d'adresses correspond à la description d'un agencement de mots- machine, si le taux de corrélation entre ces deux éléments dépasse un seuil prédéterminé et cela même s'il n'y a pas une identité stricte entre ces deux éléments. [00138] Si les positions relatives des N mots-machines lus ou écrits en mémoire par la fonction sont suffisante pour identifier sans ambiguïté cette fonction, la signature de cette fonction ne comporte pas nécessairement de séquence préenregistrée d'identifiants d'opcodes.
[00139] Avantages des modes de réalisation décrits ici :
[00140] Lors de l'exécution du programme, la séquence collectée d'identifiants d'opcodes est comparée à une séquence préenregistrée d'opcodes, ce qui permet d'identifier une fonction prédéterminée même au cours de l'exécution du code machine du programme 28. On notera que l'identification d'une telle fonction est possible, sans qu'il soit nécessaire pour cela d'instrumenter le code du programme à exécuter. En particulier, il n'est pas nécessaire d'insérer dans le programme des instructions qui indiquent explicitement quelles sont les fonctions dont l'exécution peut être accélérée. Ainsi, les procédés décrits ici fonctionnent avec tout type de programme exécutable et peu importe comment et par quel moyen ce programme exécutable a été écrit et compilé. De plus, dans le procédé décrit ici, la décision d'accélérer l'exécution ou non d'une fonction du programme est prise lors de l'exécution de ce programme et non pas lors de son écriture ou lors de sa compilation. Ainsi, contrairement au procédé connu, cette décision peut prendre en compte des données et des paramètres qui sont seulement connus lors de l'exécution du programme. Cela offre plus d'opportunités pour accélérer l'exécution du programme. Enfin, le fait d'utiliser une séquence d'identifiant d'opcodes dans la signature permet d'identifier une fonction indépendamment, notamment, de son nom ou de son adresse de branchement. Par exemple, si une même fonction existe sous deux noms différents dans le code source, cela ne change en rien les performances du procédé revendiqué lors de l'exécution du code machine obtenu après compilation de ce code source. Ainsi, le procédé décrit ici fonctionne même si le programme exécuté est déjà entièrement compilé, c'est-à-dire qu'il se présente sous la forme d'un code machine. En particulier, il s'applique aussi à d'autres programmes que ceux qui sont compilés juste au moment de leur exécution.
[00141] Le fait d'utiliser, en plus d'une séquence d'opérations, une cartographie préenregistrée des accès mémoires permet d'identifier de façon encore plus fiable et simple une fonction prédéterminée lors de l'exécution du programme. Cela permet aussi de rendre la signature plus indépendante vis-à-vis des différentes variantes possibles d'implémentation d'une même fonction.
[00142] Le fait que la cartographie comporte une description définissant l'agencement de N mots-machine indépendamment des d'opcodes exécutés immédiatement avant ou après l'accès par le microprocesseur 10 à chacun de ces mots-machine permet d'obtenir une signature plus indépendante vis-à-vis des différentes variantes possibles d'implémentation de cette fonction. Grâce à cela, le nombre de signatures à associer à un même jeu d'instructions peut être diminué tout en étant capable d'identifier le même nombre de variantes d'implémentation de cette fonction.
[00143] Le fait d'utiliser, en tant que signature d'une fonction prédéterminée, des séquences d'identifiants d'opcodes exécutés immédiatement avant ou après l'écriture ou la lecture dans l'un des mots-machine d'un agencement défini de mots-machine permet d'améliorer encore plus la fiabilité de l'identification d'une fonction lors de son exécution.
[00144] Le fait d'utiliser uniquement des séquences d'identifiants d'opcodes chacune associée à un mot-machine d'un agencement défini de N mots-machine, permet d'utiliser des séquences d'identifiants d'opcodes plus courtes, ce qui limite la taille mémoire nécessaire pour stocker une signature.

Claims

REVENDICATIONS
1. Procédé d'exécution d'un programme par un appareil électronique, ce programme comportant une fonction à réaliser et l'appareil électronique comportant un microprocesseur, caractérisé en ce que le procédé comporte :
a) la fourniture (102) :
- d'une signature préenregistrée qui identifie sans ambiguïté une fonction prédéterminée, cette signature comportant à cet effet au moins une séquence préenregistrée d'identifiants d'opcodes placés les uns derrière les autres dans l'ordre où ces opcodes identifiés doivent être exécutés pour réaliser ladite fonction prédéterminée,
- associé à chaque signature préenregistrée, un jeu prédéterminé d'instructions, ce jeu prédéterminé d'instructions étant choisi dans le groupe consistant en :
• un jeu prédéterminé d'instructions de configuration d'un accélérateur matériel configurable, ce jeu prédéterminé d'instructions étant apte, lorsqu'il est chargé dans cet accélérateur matériel, à configurer cet accélérateur matériel pour qu'il réalise ladite fonction prédéterminée plus rapidement que si cette fonction prédéterminée était exécutée par le microprocesseur,
• un code-machine directement exécutable par un coprocesseur, ce code- machine étant apte, lorsqu'il est exécuté par ce coprocesseur, à faire réaliser par le coprocesseur ladite fonction prédéterminée plus rapidement que si cette fonction prédéterminée était exécutée par le microprocesseur, et
• un code-machine directement exécutable par le microprocesseur, ce code- machine étant apte, lorsqu'il est exécuté par ce microprocesseur, à faire réaliser par le microprocesseur ladite fonction prédéterminée plus rapidement que si cette fonction prédéterminée devait, lors de l'exécution du programme, être compilée ou interprétée avant d'être exécutée par le microprocesseur, b) lorsqu'une fonction du programme est exécutée par le microprocesseur, la collecte (124) d'une signature de cette fonction, cette collecte comportant la collecte des identifiants des opcodes exécutés, dans leur ordre d'exécution, pour obtenir une séquence collectée d'identifiants d'opcodes, puis
c) la comparaison (128) de la signature collectée à la signature préenregistrée, cette comparaison comportant la comparaison de la séquence collectée à la séquence préenregistrée, la signature collectée correspondant à la signature préenregistrée seulement si la séquence collectée correspond à la séquence préenregistrée, puis d) si la signature collectée correspond à la signature préenregistrée, l'association (132) de l'adresse de branchement dans le programme où débute l'exécution de cette fonction, au jeu d'instructions associé à cette signature préenregistrée, et
e) si la signature collectée ne correspond pas à la signature préenregistrée, l'absence d'association de l'adresse de branchement dans le programme où débute l'exécution de cette fonction, au jeu d'instructions associé à cette signature préenregistrée, puis f) si l'exécution du programme retourne à une adresse de branchement associée à un jeu d'instructions, le déclenchement (120) de l'exécution de ladite fonction prédéterminée par un accélérateur matériel configuré avec ce jeu d'instructions ou le déclenchement de l'exécution par le microprocesseur ou un coprocesseur du code- machine de ce jeu d'instructions.
2. Procédé selon la revendication 1, dans lequel :
- lors de l'étape a) (102), la signature préenregistrée comporte en plus une cartographie préenregistrée des accès mémoires de la fonction prédéterminée, cette cartographie définissant les positions relatives, les uns par rapport aux autres, de N mots-machine lus ou écrits en mémoire lors de l'exécution de la fonction prédéterminée par le microprocesseur, où N est un nombre entier supérieur ou égal à quatre,
- l'étape b) (124) comporte en même temps que la collecte des identifiants d'opcodes exécutés, la collecte, dans l'ordre d'exécution des opcodes de lecture ou d'écriture en mémoire, des adresses des mots-machine lus ou écrits par la fonction exécutée pour obtenir un séquence collectée d'adresses,
- l'étape c) (128) comporte la recherche, dans la séquence collectée d'adresses, d'un ensemble de N mots-machine dont les positions relatives, les uns par rapport aux autres, correspondent aux positions relatives définies par la cartographie préenregistrée, la signature collectée correspondant à la signature préenregistrée seulement si un tel ensemble de N mots-machine est trouvé dans la séquence collectée d'adresses.
3. Procédé selon la revendication 2, dans lequel :
- lors de l'étape a) (102), la cartographie préenregistrée associe à au moins l'un des N mots-machine, une séquence d'identifiants d'opcodes exécutés immédiatement avant ou après la lecture et l'écriture d'une donnée dans ce mot-machine,
- l'étape b) (124) comporte, en même temps que la collecte de la séquence d'adresses, la collecte pour chacun des mots machines lu et écrit lors de l'exécution de la fonction, de la séquence d'identifiants d'opcodes exécutés immédiatement avant ou après la lecture ou l'écriture dans ce mot-machine,
- lors de l'étape c) (128), la signature collectée correspondant à la signature préenregistrée seulement si pour chacun des N mots-machine de l'ensemble trouvé, la séquence collectée d'identifiants d'opcodes exécutés immédiatement avant ou après la lecture ou l'écriture dans ce mot-machine correspond à la séquence d'identifiants d'opcodes associée à ce mot-machine par la cartographie préenregistrée.
4. Procédé selon la revendication 3, dans lequel chaque séquence d'identifiants d'opcodes de la signature préenregistrée est associée à un mot-machine dont la position relative par rapport aux N-1 autres mots-machine est définie par la cartographie préenregistrée.
5. Procédé selon la revendication 2, dans lequel aucun des N mots-machine dont les positions relatives, les uns par rapport aux autres, sont définies par la cartographie préenregistrée, n'est associé à une séquence d'identifiants d'opcodes exécutés immédiatement avant ou après la lecture ou l'écriture d'une donnée dans ce mot-machine.
6. Procédé selon l'une quelconque des revendications précédentes, dans lequel
- la fonction prédéterminée est une fonction paramétrable, les valeurs du ou des paramètres de cette fonction prédéterminée étant connues uniquement au moment de son exécution par le microprocesseur,
- lors de l'étape a) (102), la signature préenregistrée identifie sans ambiguïté seulement la fonction prédéterminée paramétrée avec des valeurs prédéterminées et le jeu d'instructions de configuration est seulement apte à configurer l'accélérateur matériel pour qu'il exécute la fonction prédéterminée paramétrée avec ces valeurs prédéterminées et le code machine est seulement apte, lorsqu'il est exécuté par le microprocesseur ou le coprocesseur, à faire réaliser par ce microprocesseur ou ce coprocesseur ladite fonction prédéterminée paramétrée avec ces valeurs prédéterminées,
- lors de l'étape d), l'association (132) de l'adresse de branchement à ces valeurs prédéterminées des paramètres, et
- avant de déclencher l'exécution de la fonction prédéterminée, le procédé comporte la vérification (118) que les valeurs actuelles des paramètres avec lesquels la fonction est appelée correspondent aux valeurs prédéterminées de ces mêmes paramètres associées à cette adresse de branchement et l'étape f) est déclenchée uniquement si les valeurs actuelles et les valeurs prédéterminées des paramètres sont identiques.
7. Procédé selon l'une quelconque des revendications précédentes, dans lequel :
- l'étape a) (102) comporte la fourniture de plusieurs signatures préenregistrées différentes qui identifient chacune sans ambiguïté une variantes d'implémentations respective de la même fonction prédéterminée, toutes ces signatures préenregistrées qui identifient sans ambiguïté la même fonction prédéterminée étant associées au même jeu prédéterminé d'instructions,
- lors de l'exécution du programme, l'étape c) (128) est exécutée pour chacune de ces signatures préenregistrées.
8. Procédé selon l'une quelconque des revendications précédentes, dans lequel :
- l'étape a) (102) comporte la fourniture de plusieurs signatures préenregistrées qui identifient chacune sans ambiguïté des fonctions prédéterminées respectives différentes, chacune de ces signatures préenregistrées étant associée à un jeu prédéterminé d'instructions différent de ceux auxquels sont associés les autres signatures préenregistrées, et
- lors de l'exécution du programme, l'étape c) (128) est exécutée pour chacune des signatures préenregistrées.
9. Support d'enregistrement lisible par un microprocesseur sur lequel est enregistré un programme d'ordinateur, caractérisé en ce qu'il comporte des instructions de code de programme d'ordinateur pour l'exécution des étapes d'un procédé conforme à l'une quelconque des revendications précédentes, lorsque ces instructions sont exécutées par le microprocesseur.
10. Appareil électronique apte à exécuter un programme comportant une fonction à réaliser, cet appareil électronique comportant à cet effet :
- un microprocesseur (10) programmable apte à exécuter le programme, et
- une mémoire (6),
caractérisé en ce que :
- la mémoire (6) comporte :
- une signature préenregistrée qui identifie sans ambiguïté une fonction prédéterminée, cette signature comportant à cet effet au moins une séquence préenregistrée d'identifiants d'opcodes placés les uns derrière les autres dans l'ordre où ces opcodes identifiés doivent être exécutés pour réaliser ladite fonction prédéterminée,
- associé à chaque signature préenregistrée, un jeu prédéterminé d'instructions, ce jeu prédéterminé d'instructions étant choisi dans le groupe consistant en :
° un jeu prédéterminé d'instructions de configuration d'un accélérateur matériel configurable, ce jeu prédéterminé d'instructions étant apte, lorsqu'il est chargé dans cet accélérateur matériel, à configurer cet accélérateur matériel pour qu'il réalise ladite fonction prédéterminée plus rapidement que si cette fonction prédéterminée était exécutée par le microprocesseur, et
° un code-machine directement exécutable par un coprocesseur, ce code- machine étant apte, lorsqu'il est exécuté par ce coprocesseur, à faire réaliser par le coprocesseur ladite fonction prédéterminée plus rapidement que si cette fonction prédéterminée était exécutée par le microprocesseur, et
° un code-machine directement exécutable par le microprocesseur, ce code- machine étant apte, lorsqu'il est exécuté par ce microprocesseur, à faire réaliser par le microprocesseur ladite fonction prédéterminée plus rapidement que si cette fonction prédéterminée devait, lors de l'exécution du programme, être compilée ou interprétée avant d'être exécutée par le microprocesseur,
- le microprocesseur (10) est programmé pour réaliser les étapes suivantes :
b) lorsqu'une fonction du programme est exécutée par le microprocesseur, la collecte d'une signature de cette fonction, cette collecte comportant la collecte des identifiants des opcodes exécutés, dans leur ordre d'exécution, pour obtenir une séquence collectée d'identifiants d'opcodes, puis
c) la comparaison de la signature collectée à la signature préenregistrée, cette comparaison comportant la comparaison de la séquence collectée à la séquence préenregistrée, la signature collectée correspondant à la signature préenregistrée seulement si la séquence collectée correspond à la séquence préenregistrée, puis d) si la signature collectée correspond à la signature préenregistrée, l'association de l'adresse de branchement dans le programme où débute l'exécution de cette fonction, au jeu d'instructions associé à cette signature préenregistrée, et
e) si la signature collectée ne correspond pas à la signature préenregistrée, l'absence d'association de l'adresse de branchement dans le programme où débute l'exécution de cette fonction, au jeu d'instructions associé à cette signature préenregistrée, puis f) si l'exécution du programme retourne à une adresse de branchement associée à un jeu d'instructions, le déclenchement de l'exécution de ladite fonction prédéterminée par un accélérateur matériel configuré avec ce jeu d'instructions ou le déclenchement de l'exécution par le microprocesseur ou un coprocesseur du code-machine de ce jeu d'instructions.
11. Appareil selon la revendication 10, caractérisé en ce qu'il comporte un accélérateur matériel (12) configurable dans lequel le jeu prédéterminé d'instructions est apte à être changé pour configurer cet accélérateur matériel pour qu'il réalise ladite fonction prédéterminée.
12. Appareil selon la revendication 11, dans lequel l'accélérateur matériel (12) est un composant FPGA (« Field-Programmable Gâte Array »).
13. Appareil selon la revendication 10, caractérisé en ce qu'il comporte un coprocesseur (152) apte à exécuter le jeu prédéterminé d'instructions pour qu'il réalise ladite fonction prédéterminée.
PCT/FR2018/052353 2017-09-26 2018-09-25 Procédé d'exécution d'un programme par un appareil électronique WO2019063930A1 (fr)

Applications Claiming Priority (2)

Application Number Priority Date Filing Date Title
FR1758863 2017-09-26
FR1758863A FR3071642B1 (fr) 2017-09-26 2017-09-26 Procede d'execution d'un programme par un appareil electronique

Publications (1)

Publication Number Publication Date
WO2019063930A1 true WO2019063930A1 (fr) 2019-04-04

Family

ID=61258305

Family Applications (1)

Application Number Title Priority Date Filing Date
PCT/FR2018/052353 WO2019063930A1 (fr) 2017-09-26 2018-09-25 Procédé d'exécution d'un programme par un appareil électronique

Country Status (2)

Country Link
FR (1) FR3071642B1 (fr)
WO (1) WO2019063930A1 (fr)

Cited By (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
FR3103590A1 (fr) * 2019-11-27 2021-05-28 Commissariat à l'Energie Atomique et aux Energies Alternatives Procédé de construction d’une signature caractéristique des accès, par un microprocesseur, à une mémoire

Citations (3)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US6077315A (en) 1995-04-17 2000-06-20 Ricoh Company Ltd. Compiling system and method for partially reconfigurable computing
US20150046427A1 (en) 2013-08-07 2015-02-12 International Business Machines Corporation Accelerating multiple query processing operations
US20160179489A1 (en) 2014-07-17 2016-06-23 Google Inc. Optimized execution of dynamic languages

Patent Citations (3)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US6077315A (en) 1995-04-17 2000-06-20 Ricoh Company Ltd. Compiling system and method for partially reconfigurable computing
US20150046427A1 (en) 2013-08-07 2015-02-12 International Business Machines Corporation Accelerating multiple query processing operations
US20160179489A1 (en) 2014-07-17 2016-06-23 Google Inc. Optimized execution of dynamic languages

Non-Patent Citations (5)

* Cited by examiner, † Cited by third party
Title
CAROLINE QUÉVA ET AL: "Self-optimisation using runtime code generation for wireless sensor networks", DISTRIBUTED COMPUTING AND NETWORKING, ACM, 2 PENN PLAZA, SUITE 701 NEW YORK NY 10121-0701 USA, 4 January 2016 (2016-01-04), pages 1 - 6, XP058079334, ISBN: 978-1-4503-4032-8, DOI: 10.1145/2833312.2849557 *
CAROLINE QUEVA: "Distributed Computing and networking", 4 January 2016, ACM, article "Self-optimisation using runtime code génération for wirelesss sensor networks"
PABLO DE OLIVEIRA CASTRO; CHADI AKEL; ERIC PETIT; MIHAIL POPOV; WILLIAM JALBY: "LLVM-based Codelet Extractor and REplayer for piecewise benchmarking and optimization", ACM TRANSACTIONS ON ARCHITECTURE AND CODE OPTIMIZATION (TACO, vol. 12, no. 1, 2015, pages 6
SAUMYA K DEBRAY ET AL: "Compiler techniques for code compaction", ACM TRANSACTIONS ON PROGRAMMING LANGUAGE AND SYSTEMS, ACM, NEW YORK, NY, vol. 22, no. 2, 1 March 2000 (2000-03-01), pages 378 - 415, XP058106806, ISSN: 0164-0925, DOI: 10.1145/349214.349233 *
SAUMYA K. DEBRAY: "Compiler technique for code compaction", ACM TRANSACTION ON PROGRAMMING LANGAGE AND SYSTEMS, vol. 22, no. l, 1 March 2000 (2000-03-01)

Cited By (2)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
FR3103590A1 (fr) * 2019-11-27 2021-05-28 Commissariat à l'Energie Atomique et aux Energies Alternatives Procédé de construction d’une signature caractéristique des accès, par un microprocesseur, à une mémoire
EP3828695A1 (fr) 2019-11-27 2021-06-02 Commissariat à l'Energie Atomique et aux Energies Alternatives Procédé de construction d'une signature caractéristique des accès, par un microprocesseur, à une mémoire

Also Published As

Publication number Publication date
FR3071642B1 (fr) 2019-11-22
FR3071642A1 (fr) 2019-03-29

Similar Documents

Publication Publication Date Title
US11106437B2 (en) Lookup table optimization for programming languages that target synchronous digital circuits
US8434073B1 (en) Systems and methods for preventing exploitation of byte sequences that violate compiler-generated alignment
EP3314420B1 (fr) Procédé d'exécution d'un programme d'ordinateur comportant une fonction paramétrée
EP2453356B1 (fr) Procédé, programme d'ordinateur et dispositif de sécurisation de code intermédiaire de programmation pour son exécution par une machine virtuelle
CA3123903A1 (fr) Langage et compilateur qui generent des circuits numeriques synchrones qui maintiennent un ordre d'execution de fil
FR2996037A1 (fr) Moteur hybride pour processeur central et processeur graphique
WO2012000949A1 (fr) Procédé de compilation sélective, dispositif et produit programme d'ordinateur correspondant
EP1612668A1 (fr) Procédé de transformation de code informatique et produit/programme d'ordinateur pour la mise en oeuvre d'un tel procédé
FR3071642B1 (fr) Procede d'execution d'un programme par un appareil electronique
CN106126225B (zh) 一种基于程序演进模型的目标代码逆向工程方法
EP3674995A1 (fr) Procédé de compilation d'un circuit quantique sur un processeur quantique à ions piégés
WO1995008154A1 (fr) Procede de demonstration automatique
EP3314421B1 (fr) Procédé d'exécution d'un programme d'ordinateur comportant une fonction paramétrée
EP2807557A1 (fr) Procédé de compilation, programme d'ordinateur et système informatique
EP3685259B1 (fr) Procédé d'exécution d'un code machine d'une fonction sécurisée
WO2020002782A1 (fr) Accès mémoire de processeurs
FR2960988A1 (fr) Methode de compression et de decompression d'un programme executable ou interpretable
FR2991071A1 (fr) Procede et dispositif de traitement de donnees
EP4086801B1 (fr) Procédé d'exécution d'une fonction, sécurisé par désynchronisation temporelle
EP3724779A1 (fr) Architectures de processeur
FR3103590A1 (fr) Procédé de construction d’une signature caractéristique des accès, par un microprocesseur, à une mémoire
US20230070730A1 (en) Word based channels last ordering in memory
EP1596282A2 (fr) Dispositif et procédé de gestion d'un jeu d'instructions d'un microprocesseur
EP4089557A1 (fr) Procédé d'exécution d'un code binaire par un microprocesseur
FR3116137A1 (fr) Procédé d'exécution d’un programme d’ordinateur par un calculateur électronique comportant une mémoire principale et une mémoire secondaire

Legal Events

Date Code Title Description
121 Ep: the epo has been informed by wipo that ep was designated in this application

Ref document number: 18786844

Country of ref document: EP

Kind code of ref document: A1

NENP Non-entry into the national phase

Ref country code: DE

122 Ep: pct application non-entry in european phase

Ref document number: 18786844

Country of ref document: EP

Kind code of ref document: A1