FR2919081A1 - Bijective operation implementing method for computer microprocessor, involves determining assignment sequence for assigning elementary memories from combined bijections for calculating bijective operation - Google Patents

Abstract

The method involves segmenting a bijective operation into a series of bijections, and combining the bijections based on elementary memories such as binary registers. An assignment sequence for assigning the elementary memories is determined from the combined bijections for calculating the bijective operation. The segmentation of the bijective operation into bijections is repeated in an iterative manner until the obtained bijections are directly calculated by the assignment of the elementary memories. Independent claims are also included for the following: (1) a computer program comprising a set of coding instructions for implementing a bijective operation on elementary memories (2) a computer program compiler for implementing a method for implementing a bijective operation on elementary memories (3) a method for receiving a microprocessor to implement a method for implementing a bijective operation on elementary memories.

Description

IMPLEMENTATION OF CALCULATIONS FOR PROCESSORS The present invention relates to

  calculations made by processors. In general, the processors perform calculations by sequences of simple operations of assignments on elementary memories, such as registers. These basic memories are limited in number and processor access to these memories are faster than access to other peripheral memories associated with the processors. In order to optimize the calculation times, it is therefore necessary to limit the number of accesses to the peripheral memories and to optimize the use of the elementary memories. More specifically, computation operations are often implemented with the use of additional elementary memory memories. Implementation means the completion of the final phase of the development of a system that allows the hardware elements and the software elements to function, that is to say the determination of the sequence of control in a computer system. For example, a simple operation such as the exchange of the contents of two registers denoted A and B generally uses a third memory C in which the content of one of the two registers is stored temporarily. There are also other methods of implementing computation operations using operations between the registers to avoid the use of elementary memories for storing buffer values. For example, the exchange function of the contents of two registers A and B can be carried out using the following three steps: the register A takes the value of the sum of the registers A and B; register B then takes the value of register A minus the value of register B; then, the register A takes the value of the register A less the value of the register B. After these three steps, the values of the registers A and B are exchanged.

  It is demonstrated in the publication Closed iterative calculus Theoritical Computer Science, n 158 of 1996, pages 371 to 378 by Serge Burckel, that it is possible to implement any operation on any number K of registers without using variables with such sequences of operations.

  If each of these registers has N bits, such as 32 bits for example, the number of necessary operations is of the order of NxK2 as demonstrated in the publication Quadratic Sequential Computations of Bouleon Mappings, Theory of Computing Systems, No. 37 of 2004 , pages 519-525 by Serge Burckel and Marianne Morillon.

  These techniques therefore require a large number of operations. As indicated previously, it is interesting to optimize the use of the registers in order to reduce the computing times of the processors. This also results in energy savings. An advantage of the invention is to allow a more efficient implementation of operations, especially on registers to optimize computing times and energy consumption. For this purpose, the object of the present invention is a <REV 1>. Accordingly, the total number of operations is substantially reduced so that the calculation time and the consumption are also reduced. According to other embodiments: The invention will be better understood in the light of the description and the drawings, in which: FIG. 1 is a general flowchart of one embodiment of the invention; ; Figure 2 shows the detail of a staining operation; FIG. 3 represents a numerical example of the coloring operation of FIG. 2; FIG. 4 is a general flowchart of another embodiment of the invention; and FIG. 5 is a general flow diagram of yet another embodiment of the invention. In a first embodiment, the invention is applied for the implementation of a bijective operation denoted E on a number K of binary registers.

  An operation E is bijective, if and only if two distinct antecedents, to which this operation is applied, necessarily lead to two distinct images, that is to say that two different n-tuples will not have the same image by E As a preliminary, it should also be remembered that, in general terms, a n-tuple is a vector comprising n components, each selected from the set of possible values. For example, in the binary case, the possible values are 0 and 1 and a 3-tuple is a three-bit word. The registers can each be considered as an elementary memory that can take a number M of values. In the case of binary registers, this number M is equal to 2 exposing the number N of bits of the register. It is also possible to consider a number M of values equal to 0 or 1 and to calculate bit by bit, each bit of the register being considered as an elementary memory. The sequences of successive assignments relating to bits of the same register can then be grouped into a single assignment of this register. Referring to Figures 1 to 3, will now be described the general flowchart of the method of the invention applied to a bijective operation E on K elementary memories that can take M values.

  The method firstly comprises a step 10 of segmenting the operation into a series of bijections.

  More precisely, this segmentation step is an iterative or inductive segmentation to form M bijections at each iteration until the obtained bijective functions are directly calculable by the assignments of the elementary memories.

  Thus, we formally consider a table of MK lines for the definition of E where M is the number of possible values. In general, we note: In the example, the elementary memories are bits whose possible values are S = {0,1} so that M is equal to 2. For the numerical example, K is selected equal to 3 A three-bit bijection E on A, B, C is then defined by a table of 23 lines, ie eight lines. We define for the example the following function E: E (ABC) = (ac OR AbC OR Bc; A; aB OR AC) by noting NO (A) = a, NO (B) = b, NO (C) = c and A AND B = AB.

  This logical function is defined by the table of eight lines: E (000) = 100; E (001) = 000; E (010) = 101; E (011) = 001; E (100) = 010; E (100) = 010; E (101) = 111; E (110) = 110; and E (111) = 011.

  During step 10, the bijection E is first segmented into M other bijections. During a step 12, a coloring of the lines defining the function E is applied, thanks to a classical Kôning theorem in graph theory. This coloration is achieved by distributing the terms of the function E on the edges of a bipartite graph. It is thus possible to give a color among M to each line of the table defining the function E by considering in general that two lines have a different color if the same parts of the source vectors are equal or if the same parts of the image vectors are equal. Thus, considering: = (y_1, y_2, ... y_K) and E = (b_1 ... b_K) = (z_1 ... z_K) if the straight parts of the source vectors (a_2 ... a_K) and ( b_2 ... b_K) or the straight portions of the image vectors (y_2, ... y_K) and (z_2, ... z_K) are equal, then the colors of the two lines are different. In the case of the binary set {0,1}, the coloring can be obtained algebraically as a Boolean mapping denoted C in the set of solution {0,1} satisfying: C (0, x) ≠ C (1 , x) and C (E (0, x)) ~ C (E (1, x)) for all x belonging to S. In this case, the color is given to the image part of the lines. Existing methods make it possible to obtain such colorations according to graph theory. In the particular case illustrated above, with S = {0,1}, it is possible to use the following algorithm to perform the coloring of the rows of the table, defining the operation E. This algorithm is illustrated in FIG. 2 a) if all the lines are colored, the coloring is complete; B) an unstained line is selected; c) if the current line is colored, go to a) if not coloring it by O. Considering the right part of the current line, that is to say the image part, with the exception of the first term, go to the other line having the same right part except for the first term and coloring it by the value 1; 25 d) considering the left part of the current line, that is to say the antecedents part, except for the first term, go to the other line whose left part is identical except for the first one term and proceed to step c). The application of this method results in the particular case illustrated in the following coloring also illustrated with reference to Figure 3: E (000) = 100: color 0; E (001) = 000: color 1; E (10) = 101: color 1; E (11) = 001: color 0; E (100) = 010: color 1; E (101) = 111: color 0; E (110) = 110: color 0; and E (111) = 011: color 1. If we consider each set of lines of the same color ignoring their first components, we obtain M bijections denoted E_0 to E_M-1, each on the set M K- '. in the example, the four color lines 0, forgetting their respective first component, make it possible to obtain the bijection E_0 defined by the following lines: E_0 (00) = 00; E_0 (11) = 01; E_0 (01) = 11; and E_0 (10) = 10. For lines of color 1, we thus obtain the bijection E_1 according to which: E_1 (01) = 00; E_1 (10) = 01; E_1 (00) = 10; and E_1 (11) = 11. This coloring segmentation step 12 is repeated until the obtained bijective functions are directly transformable into elementary memory assignments, i.e., bit assignments. Depending on the embodiments, this step can be repeated until we obtain bijections bearing each time on a single elementary memory or until we obtain automatically compilable bijections, that is, directly calculable in 15 assignments. This is shown with reference to FIG. 3, in which segmentation is continued until unit assignments are obtained. A test 14 makes it possible to determine whether the functions obtained can be computed into assignments, for example by comparison with a list of known functions. At the end of segmentation step 10, the method therefore delivers, for each bijection, a number M of calculation programs relating to K-1 memories, that is to say M sequences of assignments of these K -1 memories. In general terms, for each bijection E_i, for example from 0 to M-1, an assignment sequence of the following form is obtained: R_2: = E_i2 (R_2, ..., R_K);

  R_ (K-1): = E_i (K-1) (R_2, ..., R_K); R_K: = E_iK (R_2, ..., R_K); R_ (K-1): = E'_i (K-1) (R_2, ..., R_K);

  R_2: = E'_i2 (R_2, ..., R_K). Compared to the previous example, we obtain the following programs for the algebraic calculation of E_0: B: = B + C; C: = C; and B: = B. Similarly, the following program is obtained for the algebraic calculation of E_1: B: = 1 + B + C; C: = 1 + B + C; and B: = B. The method then comprises a step 16 of combining these M calculations into a calculation of the processed bijection of the following form: R_1: = E_1 (R_1, ..., R_K); R_2: = E_2 (R_1, ..., R_K); R_ (K-1): = E_ (K-1) (R_1, ..., R_K); R_K: = E_K (R_1, ..., R_K); R_ (K-1): = E '_ (K-1) (R_1, ..., R_K); R_2: =; and R_1: = E'_1 (R_1, ..., R_K). For the first term, we adopt the color of the line so that: E_1 (x_1, ..., x_K) = the color of the line of E (x_1, x_2, ..., x_K) For the example: E_1 (000) = 0; E_1 (001) = 1 E_1 (010) = 1 E_1 (011) = 0; E_1 (100) = 1 E_1 (101) = 0; E_1 (110) = 0; and E_1 (111) = 1. This results in the following algebraic assignment: A: = A + B + C. The other terms are conditionally defined according to the previous term. Thus, E_2 is defined by the following cases: E_2 (x_1, ..., x_K) = if x_1 = 0 then E_02 (x_2, .., x_K); if x_1 = 1 then E_12 (x_2, .., x_K);

  if x_1 = M-1 then E_ (M-1) 2 (x_2, .., x_K). In the same way, we define the assignments E_3, ..., E_K, E '_ (K-1), ..., E'_2. For the example we obtain the following conditional assignments: B: = if A = 0 then (B + C); if A = 1 then (1 + B + C); C = if A = 0 then (C); if A = 1 then (1 + B + C); B = if A = 0 then (B); and if A = 1 then (B). These different assignments translate into: B: = (1 + A) * (B + C) + A * (1 + B + C); C = (1 + A) * C + A * (1 + B + C); and B: = (1 + A) * B + A * B.

  It is then possible to simplify these assignments during a step 18 to obtain the following sequences: B: = A + B + C; C = A + C + A * B; and B B.

  Finally, the last assignment f'_1 is determined in a similar way to f_1 using the color of the line so that: = y_1 for the color line x_1 of the form: E (...) = In the illustrated example previously: f'_1 (000) = 1 because the color 0 f'_1 (001) = 0 because the color 0 f'_1 (010) = 1 because the color 0 f'_1 (011) = 1 because the color 0 f'_1 (100) = 0 because the color 1 f'_l (101) = 1 because the color 1 f'_1 (110) = 0 because the color 1 f'_l (111) = 0 because the color 1 was data was given was data was data was given was given at E (000) = 100; at E (011) = 001 to E (110) = 110; at E (101) = 111 to E (001) = 000; at E (010) = 101 to E (100) = 010; and E (111) = 011. This is translated algebraically by the assignment A: = 1 + A + C + B * C.

  It is then possible after combination complete expression of the calculation of the bijection E: and simplification to obtain a A: = A + B + C; B = A + B + C; C = A + C + A * B; B B; and A = 1 + A + C + B * C.

  The method of the invention thus makes it possible to express the operation E by a series of 2K-1 assignments which are easily implementable at the microprocessor level. These assignments are made in ascending and descending order from a first elementary memory to a last elementary memory and then in the corresponding descending order. However, the initial order of the memories can be chosen arbitrarily. These assignments may in particular be implemented by standard methods, in particular with logic gates, such as NAND gates 10 commonly used in current processors. It should also be noted that the expression of the operations can be done indifferently in a polynomial, logical or binary manner. Moreover, the principle of the invention can also be extended more generally to any type of operation and in particular to non-bijective operations. Thus, by calling E any operation on K registers that can each take M values, it is possible to compute the operation E by a sequence of 5K-4 assignments. FIG. 4 represents a general flowchart of the method of the invention applied to a non-bijective operation. The process begins with a preliminary step of constructing two bijections and a single application. Step 30 firstly comprises a substep 32 for determining a bijection F that makes it possible to assign consecutive elements in packets in the lexicographic order to all K-tuplets having the same image by E. Then, a simple application P is determined during a substep 34. This application P transforms consecutive elements into the corresponding packet number, this number being itself represented in base M by a K-tuplet. More precisely, the bijection F and the application P are obtained by the following algorithm using the function NEXT which, at a given k-tuplet, associates the value of the following k-tuplet in the lexicographic order: a) for all K-tuplets x, the images F (x) and P (x) are undefined and R and T are the null K-tuples: R == T = (0,0,0, ..., 0); b) if F is everywhere defined then the algorithm is finite; c) for an x such that F (x) is indefinite do: as long as there exists an x 'such that E (x') = E (x) and F (x ') is undefined make: F (x') = T; P (T) = R; T = NEXT (T); d) R = NEXT (R) and go to b). Here is a numerical example with M = 2 and K = 3. We have NEXT (000) = 001; NEXT (001) = 010; NEXT (010) = 011; NEXT (011) = 100 etc. For the example, consider an operation E defined on three bits ABC by the following table: E (000) = 101 E (001) = 000; E (010) = 101 E (011) = 001 E (100) = 000; E (101) = 101 E (110) = 001; and E (111) = 000. This operation corresponds to the following logical definition: E (ABC) = (ac OR AbC, FALSE, ac OR aB OR Bc OR AbC).

  The application of the algorithm defined above makes it possible to obtain the following definition of the functions F and P: The number at the head of the line indicates the order in which the lines were considered. To calculate the application P, we identify successively each K-tuplet (x_1, ..., x_K) with its image P (x_1, .., x_K) = (Y_1, ..., Y_K) of the line towards the 1: F (000) = 000 P (000) = 000; 4: F (001) = 011 P (011) = 001; 2: F (010) = 001 P (001) = 000; 7: F (011) = 110 P (110) = 010; 5: F (100) = 100 P (100) = 001; 3: F (101) = 010 P (010) = 000; 8: F (110) = 111 P (111) = 010; and 6: F (111) = 101 P (101) = 001. left. K assignments are sufficient to calculate P. More precisely, we define K applications of MK in M p_K, ..., p_2, p_1 such that for every K-tuplet x and all i of 1 to K: if x = (x_1, .., x_i, ..., x_K) and P (x) = (Y_1, ..., Y_i, ..., Y_K) then p_i (x_1, .., x_ (i-1) , x_i, Y_ (i + 1), .., y_k) = y_i. In the case of the numerical example used previously, we obtain p_3, p_2, p_1 of {0,113 in {0,1} according to the following principle: as P (000) = (000) then p_3 (000) = 0 p_2 ( 000) = 0 p_1 (000) = 0; as P (001) = (000) then p_3 (001) = 0 p_2 (000) = 0 p_1 (000) = 0; as P (010) = (000) then p_3 (010) = 0 p_2 (010) = 0 p_1 (000) = 0; as P (011) _ (001) then p_3 (011) = 1 p_2 (011) = 0 p_1 (001) = 0; as P (100) = (001) then p_3 (100) = 1 p_2 (101) = 0 p_1 (101) = 0; as P (101) = (001) then p_3 (101) = 1 p_2 (101) = 0p_1 (101) = 0; as P (110) = (010) then p_3 (110) = 0 p_2 (110) = 1 p_1 (110) = 0; and as P (111) = (010) then p_3 (111) = 0 p_2 (110) = 1 p_1 (110) = 0. The values of the undefined p__i (x) are arbitrarily extended. They can be chosen in such a way as to make the most easily calculable. If we choose here p_2 (111) = 1 and p_1 (111) = 0, we obtain the following sequence of assignments, expressed in logical form: C: = aBC OR Ab; B: = AB; and A: = FALSE. Or by the sequence of algebraic assignments as follows: C: = A + A * B + A * B * C + B * C; B: = A * B; and A: = 0. The method then comprises a substep 36 for determining another bijection denoted by G which transforms a packet number into the image by E of the K-start tuples identified by this packet number.

  The bijection G thus verifies for every K-tuplet, we have G (P (F (x))) = E (x). In the example G is defined by: G (000) = 101 because the elements of the number 000 packet have an image 101; G (001) = 000 because the elements of the package number 001 have the image 000; G (010) = 001 because the elements of packet number 010 have the image 001; G (011) = optionally, for example, 011; G (100) = optionally, for example 100; G (101) = optionally, for example 010; G (110) = optionally, for example, 110; and G (111) = optionally, for example, 111.

  The operation E is thus expressed in the form of two bijections F and G and an application P. In general, it is considered that the bijection F is determined from the operation to be transformed in order to assign a different image to each antecedent having the same image by this operation to be transformed.

  The application P makes the link between the antecedents and the images obtained by the first bijection. The second bijection G transforms the products obtained by the bijection F and the application P to form the terms of the operation to be transformed. The method then consists in applying the segmentation of the bijective case explained previously in turn to each of the bijections F and G. During a step 40, the bijection F is transformed into a sequence of 2K-1 assignments so that any K- uplet x is transformed into y = F (x) by a sequence of assignments. Thus, at the end of step 40, a sequence of 2K-1 is obtained 30 assignments for calculating F :: = f_K (R_1, ..., R_K); R_K R_ (K-1): = f_ (K-1) (R_1, ..., R_K); R_2: = f_2 (R_1, ..., R_K); R_1: = f_1 (R_1, ..., R_K); R_2: = f'_2 (R_1, ..., R_K); R_ (K-1): = f '_ (K-1) (R_1, ..., R_K); and R_K: = f'_K (R_1, ..., R_K). In the illustrated case, the calculation is built from right to left. It is a construction similar to the case explained previously because it is enough to symmetry to transform the relations F (x_1, ..., x_K) = (y_1, ..., y_K) in F '(x_K, ..., x_1 ) = (y_K, ..., y_1) then apply the calculation method for the bijection F '. In the case illustrated, the following function F 'is obtained: F (000) = 000 therefore F' (000) = 000; F (001) = 011 therefore F '(100) = 110; F (010) = 001 therefore F '(010) = 100; F (011) = 110 therefore F '(110) = 011; F (100) = 100 therefore F '(001) = 001; F (101) = 010 therefore F '(101) = 010; F (110) = 111 therefore F '(011) = 111; and F (111) = 101 therefore F '(111) = 101. This function is transformed at the end of step 40 into the following calculation sequence: C = A + B + C + A * B; B: == A + B + A * C; A = A + B + B * C; B: = B + C + A * C; and C: = A + C + A * B. The method then comprises a step 42 of calculating the application of the function P so that every K-tuplet is replaced by its image z = P (y) in K assignment steps: R_K: = p_K (R_1, ..., R_K); R_ (K-1): = p_ (K-1) (R_1, ..., R_K); R_2: = p_2 (R_1, ..., R_K); and R_1: = p_1 In the example, this results in the following assignments: C: = A + A * B + A * B * C + B * C; B: = A * B; Finally, the method comprises a step 44 of calculating the bijection G according to the method explained previously so that any K-tuplet z is transformed by the bijections method into t = G (z) into 2K- 1 steps: R_1: = g_1 (R_1, ..., R_K); R_2: = g_2 (R_1, ..., R_K);

  R_ (K-1): = g_ (K-1) (R_1, ..., R_K); R_K: = g_K (R_1, ..., R_K); R_ (K-1): = g '_ (K-1) (R_1, ..., R_K);

  R_2: = g'_2 (R_1, ..., R_K); and R_1: = g'_1 (R_1, ..., R_K). This time, the bijection decomposed from left to right in contrast to the segmentation of the bijection F. For the example we chose: G (000) = 101 G (001) = 000; G (010) = 001 G (011) = 011 G (100) = 100; G (101) = 010; G (110) = 110; and G (111) = 111. The method of the invention results in the following sequence of assignments for the calculation of G: A A + B + B * C; B: = B + A * C; C: = 1 + A + B + C; B = B + A * C; and A: = A + B + C. The assignments are then combined in a step 46 to obtain 5K-2 assignments that successively modify the registers of 10 numbers: K, K-1, ..., 2,1,2, ... K- 1, K, K, K-1, ..., 2,1,1,2, ..., K-1, K, K-1, ... 2.1. In the example, we obtain: C: == A + B + C + A * B; B: == A + B + A * C; A = = A + B + B * C; B: == B + C + A * C; C: == A + C + A * B; C: == A + A * B + A * B * C + B * C; B: == A * B; A: = 0; A = = A + B + B * C; B: == B + A * C; C: == 1 + A + B + C; B: == B + A * C; and A: == A + B + C. The method finally comprises a step 48 for simplifying the successive assignments relating to the same register. For example, the sequence of two assignments: A: = (B + C) * F and A: = A * D + B + 4 * A, boils down to one by replacing in the second assignment the A's by the value taken by A in the first assignment. We thus obtain A: = [(B + C) * F] * D + B + 4 * [(B + C) * F]. Similarly, again as an example, the sequence of two assignments A: _ (B + C) * F and A: = G + H is summarized in one by substituting in the 25 second the A by the value taken by A in the first. However, in this case, the second assignment is independent of the value of A, so that only the second assignment is taken into account to obtain: A: = G + H. In the example, the following assignments: C: = A + C + A * B; and C: = A + A * B + A * B * C + B * C, are formally summarized as: C: = A + A * B + A * B * [A + C + A * B] + B * [A + C + A * B] that is 10 15 A: = 0, and A: = A + B + B * C, can be summarized as:: == [0] + B + B * CA that is to say: = B + B * C. The method thus makes it possible to obtain, for the calculation of operation E, a sequence of 5K-4 assignments which successively modify the number registers: K, K-1, ..., 2, 1, 2,. ..K-1, K, K-1, ..., 2,1,2, ..., K-1, K, K-1, ... 2.1. The calculation of the example is thus expressed in 5K-4 = 11 steps: C: = A + B + C + A * B 15 B: == A + B + A * CA: == A + B + B * CB: = B + C + A * CC: == A + C + A * B + B * CB: = A * B 20 A: = B + B * CB: = B + A * CC = 1 + A + B + CB: = B + A * CA: = A + B + C As before, all these assignments can be implemented by electronic circuits with logic gates and in particular, NAND gates only as is currently the case in the processors. Noting (PQ) for P NAND Q, the calculation of the example with NAND gates becomes: C: = (((1 C) ((1 A) (1 B))) ((1 B) (1 (C (1A))))); B ((B (A (1 C))) ((1 C) (1 (A (1 B))))); A ((A (B (1 C))) ((1 C) (1 (B (1 A))))); C: = A + A * B + B * C + A * B * C. Similarly, the sequence of assignments:

  5 18 B :: = ((B (C (1A))) ((1B) (1 (C (1A))))); C :: = (((1 B) (1 (C (1 A)))) ((1 C) (1 (A (1 B))))); B :: = (1 (AB)); A :: = (1 (B (1 C))); B :: = ((B (AC)) ((1 B) (1 (AC)))); C :: = (((AB) ((AC) (BC))) ((1 C) ((AB) ((1 A) (1 B))))); B :: = ((B (AC)) ((1 B) (1 (AC)))); and A :: = (((BC) ((B (1A)) (C (1A)))) ((C (AB)) ((1C) (A (1B))))). The method of the invention therefore makes it possible to implement any operation on K registers using 5K-4 assignments on these registers or, advantageously, 2K-1 assignments if this operation is bijective. The number of operations is therefore substantially reduced so that the calculation time is limited and the consumption minimized. On the other hand, it is also possible to optimize the general method described above in order to reduce the sequence of assignments to 4K-3 assignments and possibly 4K assignments, illustrated with reference to Fig. 5. In this embodiment, the process begins with a step of scheduling 50 sets of K-tuples with the same image by E so that, for all k, 0 <k <K + 1, and for any integer j positive or zero, the sets consecutive numbers whose number is between j2Ak and (j + 1) 2Ak-1 have a total number of elements multiple of 2 ^ k. More precisely, this scheduling step 50 begins by calculating the number n of K-tuplet sets having the same image by E. Next, step 50 comprises a set numbering 54 of the sets by an SAK N-application in the interval of integers [1..n]. The numbering is followed by a memorization 56 of the sizes of the sets by an application T of [1..n] in [1..2 ^ K]. In the example, the scheduling step 50 is implemented by the following algorithm in which the k-tuples are considered integers between 0 and 2AK-1: a). For all K-tuplets x, the image N (x) is undefined. Initialization: n: = 05 b). If N is everywhere defined then STOP. c). For an x such that N (x) is indefinite make: n: = n + 1; N (x) = n; T (n): = 1; As long as there exists x 'such that N (x') is indefinite and E (x) = E (x ') make N (x'): = n; T (n): = T (n) +1 We then define an algorithm that will allow induction grouping satisfying the desired properties. This algorithm is implemented from n which is the number of sets and T which is the list of sizes of sets. The algorithm delivers an output m which is the number of new sets and an output S which is the assignment of the old sets in the new ones. In this case, it is an algorithm of the set [1..n] in the set [1..m] with M which is the size list of the new sets divided by 2. This algorithm is expressed as follows: j: = 1; parity: = false; For i varying from 1 to n if T [i] is odd then do parity = false then make M [i]: = j; S [j] = T [i]; parity: = true; if parity = true then make M [i]: = j; S [j]: = (S [j] + T [i]) / 2; j: = j + 1; parity: = false; For i varying from 1 to n if T [i] is even then make M [i]: = j; S [j] = T [i] / 2; j: = j + 1; m = j-1; It is also possible to group pairs of cardinal pairs together. However, he may remain in the end a set of isolated cardinal pairs. Then, each k-tuplet is associated with a list (N_1, N_2, ..., N_ {I-1}, N_I) of grouped set numbers, noting I the number of successive groupings performed. This results in the following algorithm: T_1: = T; n_1: = n; N_1: = N; i: = 1; as n> 0 do Grouping (Input: Output: M, T_ {i + 1}, n_ {i + 1}) for x varying from 0 to 2AK-1 make N_ {i + 1} [x]: = M [N_i [x]]; i: = i + 1; I: = i-1; We define after a colexicographic comparison algorithm I-tuplets Function Lower (Input x, y: K-tuples): boolean Output t: true if x <y for the order considered or if E (x) = E (y) false if x> yi: = 1 as long as t is indefinite and i> 0 to do if N_i [x] <N_i [y] then t = true if N_i [x]> N_i [y] then t = false 15 if N_i [ x] = N_i [y] then i: = i-1 if i = 0 then t: = true We finally define, during a substep 58, a bijection F and an application P. These bijection F and application P are obtained similarly to the previous embodiment but in the order of construction by the following algorithm: a). For all K-tuples x, the images F (x) and P (x) are undefined. Initialization: R and T are the null K-tuples: R = T = (0,0,0, ..., 0). b). If F is everywhere defined then STOP. 25 (c). For an x such that F (x) is indefinite AND such that for all y such that F (y) is indefinite we have Lower (x, y) do: As long as there exists an x 'such that E (x') = E (x) and F (x ') is undefined make F (x') = T; P (T) = R; T = NEXT (T) 30 d). Make R = NEXT (R) and go to B. As desired, the order obtained from sets of K-tuples having the same image by E satisfies: for all k, 0 <k <K + 1, and for any integer j positive or zero, the consecutive sets whose number is between j2Ak and (j + 1) 2Ak-1 have a total number of elements multiple of 2 ^ k. By way of example, the method of the invention will be applied to the application E given by the following table: E (000) = 101 E (001) = 000 E (010) = 101 E (011) = 001 E (100) = 000 E (101) = 101 E (110) = 001 E (111) = 000 By traversing the set of K-tuplets, for example, in the natural order, the first grouping N = N_1 is the following: N (000) = 1 N (001) = 2 N (010) = 1 N (011) = 3 N (100) = 2 N (101) = 1 N (110) = 3 N (111) = 2. We deduce the first size table: T (1) = 3 T (2) = 3 T (3) = 2. This first array is already ordered with odd-sized sets first. We then proceed with the second grouping: N_2 (000) = 1 N_2 (001) = 1 N_2 (010) = 1 N_2 (011) = 2 N_2 (100) = 1 N_2 (101) = 1 N_2 (110) = 2 N_2 (111) = 1. This second grouping results in the colexicographic order of the following (N_1, N_2): 000,010,101 <001,100,111 <011,110. In this example we thus achieve the same applications as before. This however is not the general case.

  The method then comprises a step 60 of segmenting the function F as in the previous embodiment. However, in this embodiment the sets of K-tuplets having the same image by E are sent on consecutive elements in the order calculated in step 1. By contrast, any order could be used in the mode. previous realization. The first bijection is calculated here also from right to left. More precisely, the bijection F is computed by the bijections method, exactly as in the previous method, from right to left. That is, any K-tuplet x is transformed into y = F (x) by a sequence of operations on the registers (R_1, ..., R_K) R_K: = f_K R_ (K-1 ): = f_ (K-1) (R_1, ..., R_K) R_2: = f_2 (R_1, ..., R_K) R_1: = f_1 (R_1, ..., R_K) R_2: = f'_2 (R_1, ..., R_K) 1: F (000) = 000 P (000) = 000 4: F (001) = 011 P (011) = 001 2: F (010) = 001 P (001) = 000 7: F (011) = 110 P (110) = 010 5: F (100) = 100 P (100) = 001 3: 9101) = 010 P (010) = 0008: F (110) = 111 P (111) = 010 6: F (111) = 101 P (101) = 001 R1 (K-1): = f '_ (K-1) (R1,..., R_K) R1 = f _K (R_1, ..., R_K) In the example we obtain again: C: = A + B + C + A * BB: = A + B + A * CA: = A + B + B * CB: = B + C + A * CC: = A + C + A * B The process continues, as in the previous case by a step 70 of segmentation of the function G. However, the second bijection is calculated this time from right to left, like the first one, and in the "complete calculation" one stops at the calculation in 5K-2 assignments, just before the last simplification. More precisely, we then define a bijection G such that for every K-tuplet x we have: G (P (F (x))) = E (x) For the example we can therefore take the same: G (000) = 101 because the elements of the number 000 package have the image 101 000 001 G (001) = 000 because the elements of the package number 001 have the image G (010) = 001 because the elements of the package number 010 have the image G (011 ) = optional eg 011 G (100) = optional eg 100 G (101) = optional eg 010 G (110) = optional eg 110 G (111) = optional eg 111 This is again calculated by the bijections method, but this time from right to left.

  As a result, any K-tuplet z is transformed into t = G (z) by a sequence of operations on the registers. This sequence is expressed here: R_K: = g_K (R_1, ..., R_K) R_ (K-1): = g_ (K-1) (R_1, ..., R_K) 24 R_2: = g_2 R_1: = g_1 R_2: = g'_2 (R_1, ..., R_K) (R1, ..., R_K) (R1, ..., R_K) R_ (K-1): = g '_ (K -1) (R_1, ..., R_K)

  R_K For the example we had chosen G (000) = 101 G (001) = 000 G (010) = 001 G (011) = 011 G (100) = 100 G (101) = 010 G (110) = 110 G (111) = 111 The method for the bijections gives the computation: C: = A + C + A * BB: = BA: = 1 + A + B + C + B * CB: = 1 + A + B + C + A * CC: = 1 + B + C The method then comprises a step 80 of replacing the sequence of the first K assignments calculated in step 70 applied to the 25 packets defining a bijection G_1 in a sequence of K assignments applied to the K -uplets for directly programming the application composed of G_1 and P. In comparison with the previous embodiment, a scheduling step was added at the beginning and the calculation step in K 30 assignments of the application P, which was replaced by a final step of calculation in K assignments of the application composed of P and the first sequence of K assignments. More precisely, let G_1 be the bijection defined by the first K assignments defining G which is composed of G_2 and G_1, that is to say that u = G_1 (z) is defined by R_K: = g_K (R_1, ..., R_K ) R_ (K-1): = g_ (K-1) (R_1, ..., R_K) R_2: = g_2 (R_1, ..., R_K) R_1: = g_1 (R_1, ..., R_K) where were calculated in the previous step. The application which associates u = G_1 (P (y)) = H (y) is then defined directly by: R_K: = h_K (R_1, ..., R_K) R_ (K-1): = h_ (K-1) (R_1, ..., R_K)

  R_2: = h_2 (R_1, ..., R_K) 15 R_1: = h_1 (R_1, ..., R_K) where the applications h_i are defined by: for all y = (y_1, .., y_i, ... , y_K) with P (y) = (Z_1, ..., Z_i, ..., Z_K) we have

  This definition is partial but sufficient for the purposes of the process of the invention. In the example, the application G_1 is defined by the three assignments: C: = A + C + A * BB: = BA: = 1 + A + B + C + B * C 25 That is to say: G_1 (000) = 100 G_1 (001) = 001 G_1 (010) = 010 G_1 (011) = 011 G_1 (100) = 101 G_1 (101) = 000 G_1 (110) = 110 G_1 (111) = 111. From where the application H programmed by the successive modification of the variables C, B, A respectively by h_3, h_2, h_1 H (000) = 100 ie h_3 (000) = 0, h_2 (000) = 0, h_1 (000) = 1 H (001) = 100 that is h_3 (001) = 0, h_2 (000) = 0, h_1 (000) = 1 H (010) = 100 c is h_3 (010) = 0, h_2 (010) = 0, h_1 (000) = 1 H (011) = 001 that is h_3 (011) = 1, h_2 (011) = 0, h_1 (001) = 1 H (100) = 001 that is to say h_3 (100) = 1, h_2 (101) = 0, h_1 (101) = 0 H (101) = 001 that is to say h_3 (101) ) = 1, h_2 (101) = 0, h_1 (101) = 0 H (110) = 010 that is h_3 (110) = 0, h_2 (110) = 1, h_1 (110) = 0 H ( 111) = 010 ie h_3 (111) = 0, h_2 (110) = 1, h_1 (110) = 0 Which can be expressed algebraically, for example, by the formulas: C: = A + A * B + B * C + A * B * CB: = A * BA: = 1 + A Finally, we calculated the application E as composed of the bijection F in 2K-1 assignments, then the application G_1 composed with P in K assignments, then the bijection G_2 in K-1 assignments. We thus obtain a method in 4K-2 steps that successively modify the number registers: K, K-1, ..., 2,1,2, ... K-1, K, K, K-1 ,. .., 2,1,2, ..., K-1, K the example: CBABC As previously, two successive steps on the same K register are simplified in a single operation during a step 90. We thus obtain For: = A + B + C + A * B: = A + B + A * C: = A + B + B * C: = B + C + A * C: = A + C + A * B: = A + A * B + B * C + A * B * C: = A * B: = 1 + A: = 1 + A + B + C + A * C: = 1 + B + C 4K-3 operations. In the example, the two assignments: C: = A + C + A * BC: = A + A * B + B * C + A * B * C can be replaced by the assignment: C: = A + A * B + B * C + A * B * C We finally obtain a process in 4K-3 stages that successively modify the number registers: K, K-1, ..., 2,1,2, ... K-1, K, K-1, ..., 2,1,2, ..., K-1, K In the example, the starting application E is finally programmed by the 9 assignments: C: = A + B + C + A * BB: = A + B + A * CA: = A + B + B * CB: = B + C + A * CC: = A + A * B + B * C + A * B * CB: = A * BA: = 1 + AB: = 1 + A + B + C + A * CC: = 1 + B + CA additional title another example is described here. We consider the application E on 3 bits defined by: E (000) = 101 E (001) = 001 E (010 = 101 E (011) = 000 E (100) = 110 E (101) = 101 E (110) ) = 000 E (111) = 110 The first grouping N = N_1 gives, for example: N (000) = 3 N (001) = 1 20 25 30 N (010 = 3 N (011) = 2 N (100) = 4 N (101) = 3 N (110) = 2 N (111) = 4 The sizes are: T (1) = 1 T (2) = 2 T (3) = 3 T (4) = 2 They must be reordered to have a size order 1,3,2,2 (for example) from which a second grouping N_2 (1) = 1 N_2 (2) = 2 N_2 (3) = 1 N_2 (4) = 3 and the associated sizes: T_2 (1) = 2 T_2 (2) = 1 T_2 (3) = 1 The third grouping provided by the algorithm is useless here since the desired conditions are already satisfied, that is to say that the two consecutive pairs have a cardinal multiple of 4. It is therefore possible to stop at 1 = 2. The K-tuples are therefore associated with the following I-tuples: 000 to (3,1) 001 to (1,1) 010a (3,1) 011 to (2,2) 100 to (4,3) 101 to (3,1) 110 to (2,2) 111 to (4,3) This gives in the colexicographic order: 001 <1,000,010,101) 1,110 <1 00,111 Thus we obtain the following applications F and and P, by numbering in the order of construction: 2: F (000) = 001 P (001) = 001 1: F (001) = 000 P (000) = 000 3: F (010) = 010 P (010) = 001 5: F (011) = 100 P (100) = 010 7: F (100) = 110 P (110) = 011 4: F (101) = 011 P (011) = 001 6: F (110) = 101 P (101) = 010 8: F (111) = 111 P (111) = 011 Then, the bijection F is obtained by the decomposition method d a bijection as in the previous embodiments. To simplify the notation it is written as two successive bijections F_1 then F_2 composed of F_2 and F_1 and obtained respectively by the first K and the following K-1 assignments: F_1 (000) = 000 F_2 (000) = 001 F_1 (001 ) = 001 F_2 (001) = 000 F_1 (010) = 010 F_2 (010) = 010 F_1 (011) = 111 F_2 (111) = 100 F_1 (100) = 100 F_2 (100) = 110 F_1 (101) = 011 F_2 (011) = 011 F_1 (110) = 110 F_2 (110) = 101 F_1 (111) = 101 F_2 (101) = 111 Subsequently, for the bijection G one can choose for example: G (000) = 001 G (001) = 101 G (010 = 000 G (011) = 110 G (100) = 010 20 25 30 G (101) = 011 G (110) = 100 G (111) = 111 This bijection G is calculated by the bijections method, as two successive bijections G_.1 then G_2 obtained respectively by the first K first assignments and the following K-1: G_1 (000) = 000 G_2 (000) = 001 G_1 (001) = 101 G_2 ( 101) = 101 G_1 (010) = 011 G_2 (011) = 000 G_1 (011) = 110 G_2 (110) = 110 G_1 (100) = 010 G_2 (010) = 010 G_1 (101) = 001 G_2 (001) = 011 G_1 (110) = 100 G_2 (100) = 100 G_1 (111) = 111 G_2 (111) = 111 The H application obtained p ar P then G_1 is calculated directly by K assignments of the registers of K to 1: H (000) = 000 ie h_3 (000) = 0, h_2 (000) = 0, h_1 (000) = 0 H ( 001) = 101 ie h_3 (001) = 1, h_2 (001) = 0, h_1 (001) = 1 H (010) = 101 that is h_3 (01 0) = 1, h_2 ( 011) = 0, h_1 (001) = 1 H (011) = 101 that is h_3 (011) = 1, h_2 (011) = 0, h_1 (001) = 1 H (100) = 011 c is h_3 (100) = 1, h_2 (101) = 1, h_1 (111) = 0 H (101) = 011 that is h_3 (101) = 1, h_2 (101) = 1, h_1 (111) = 0 H (110) = 110 that is to say h_3 (110) = 0, h_2 (110) = 1, h_1 (110) = 1 H (111) = 110 ie h_3 (111) ) = 0, h_2 (110) = 1, h_1 (110) = 1 Finally the application E obtained by F_1 then F_2 then H then G_2 is obtained as a sequence of 4K-2 assignments, and the register K being modified two consecutive times in the middle of the table can be simplified in 4K-3 steps. It is also possible to reduce the number of assignments to 4K 30 when, with S = {0,1 .... M-1} we have 2 ^ (k-1) <M <2 ^ k + 1. In this case, it is possible to group k successive bits. Indeed, the three simplifications performed when a bit is changed twice in a row are deleted because it is the entire block of k bits that must be modified. This results in a gain of three operations 10 resulting in 4k assignments. Of course, various embodiments are possible. In particular, the segmentation and the implementation can be done in real time in a program executed by a computer or a micro component in order to obtain the sequence of assignments. The method can also be used to create reference tables for expressing functions in the form of an assignment sequence. A component then comes to consult these tables when using the functions.

  Thus, the invention can be implemented by a compiler or during the design of microprocessors. The principles of the invention can also be applied to large sets of values by combining the assignment sequences constructed to act on successive bits by grouping them together to determine a single assignment for all the bits of the register. Thus, the computation is constructed by acting bit by bit then, is grouped by block of assignment of bits in assignment of registers. For example, the function of exchange of the contents of two bit registers A and B on N bits can be carried out bit by bit and the following calculation sequence is obtained on the registers: 1 the register A takes the value A XOR B; 2 the register B takes the value A XOR B; 3 the register A takes the value A XOR B; where XOR is the bitwise bitwise addition. At the end of these three steps, the 25 values of the registers A and B are exchanged.

Claims (19)

  1. Method for implementing an operation (E) on any number K, strictly greater than 1, of elementary memories (A, B, C) each capable of taking M values, characterized in that it comprises the following steps at least one segmentation (10; 40,44; 60,70) of the operation into a series of bijections; a combination (16; 46; 90) of said bijections as a function of the elementary memories they affect; a determination (18, 48) of an assignment sequence of the elementary memories from said combined bijections to perform the calculation of said operation (E).   2. Method according to claim 1, characterized in that said operation is bijective and in that said segmentation step comprises a segmentation (12, 14) in M bijective functions each bearing on K-1 memories.   3. Method according to claim 2, characterized in that said step of segmenting the operation in bijections is renewed iteratively until the resulting bijections are directly calculable by assignments of the elementary memories on which they relate.   4. Method according to claim 3, characterized in that said segmentation step comprises at least one M color staining at each iteration.   5. Method according to any one of claims 2 to 4, characterized in that said step of determining a series of assignments delivers a sequence of 2K-1 assignments performed on K elementary memories.   6. Method according to claim 1, characterized in that it comprises a step (30) prior to decomposition of the operation in two bijections (F and G), and an application (P) each relating to K variables and said segmentation step comprises a segmentation (40, 44) of each of these bijections (F, G) into M bijective functions.   7. Method according to claim 6, characterized in that said preliminary step (30) of decomposition comprises the determination (32) of a first bijection (F) from the operation to be transformed in order to assign a different image to the antecedents having the same image by the operation to be transformed, determining (34) a sequence of K assigning calculation of an application (P) which identifies in packets the images obtained by the first bijection, and the determination (36) ) a second bijection (G) transforming the products obtained by said first bijection and said application to form the terms of the operation to be calculated.   8. Method according to any one of claims 6 and 7, characterized in that said two bijections are calculated by operations performed on the elementary memories in descending and increasing order to obtain said first bijection and symmetrically in ascending and descending order to obtain said second bijection.   9. Method according to any one of claims 6 to 8, characterized in that said step of determining a series of assignments delivers a sequence of 5K-4 assignments performed on the elementary memories.   10. Method according to claim 1, characterized in that it comprises a prior step (50) scheduling antecedents having the same image by said operation (E), and a step of decomposing the operation into two bijections (F and G), and an application (P) each relating to K variables and in that said segmentation step comprises a segmentation (60, 70) of each of these bijections (F, G) into M bijective functions.   11.Procédé according to claim 6, characterized in that said prior step (50) of scheduling comprises calculating (52) the number of sets of antecedents having the same image, the count (54) of these sets and their memorizing (56).   12. Method according to any one of claims 10 and 11, characterized in that said two bijections are calculated by operations performed on the elementary memories in descending and increasing order for obtaining said first bijection and symmetrically. in ascending and descending order to obtain said second bijection.   13.Procédé according to any one of claims 10 to 12, characterized in that said step of determining a series of assignments delivers a sequence of 4K-3 assignments performed on the elementary memories.   14.Procédé according to any one of claims 10 to 13, characterized in that the parameters K and M are such that 2 ^ (k-1) <M <2Ak + 1 and in that said step of determining a Assignment Series Delivers a Sequence of 4Kassignations Performed on Elementary Memories   15. Method according to any one of the preceding claims, characterized in that said combining step comprises grouping and simplifying (18; 48) assignments relating to the same elementary memories.   16.Computer program comprising instruction code instructions for implementing the steps of a method according to any one of the preceding claims, during an execution by a computer of said computer.   17. A computer processor having a program in accordance with claim 16 in a memory.   18.Computer program compressor comprising means for implementing the method according to any one of claims 1 to 15 for the implementation of at least one operation.   19.Process for designing a microprocessor comprising at least one step of implementing an operation according to the method according to any one of claims 1 to 15.