WO2006063911A1

WO2006063911A1 - Method for positioning elementary data of a data structure in a storage unit

Info

Publication number: WO2006063911A1
Application number: PCT/EP2005/055966
Authority: WO
Inventors: Laurent Lagosanto; Antoine Requet; Jean-Jacques Vandewalle
Original assignee: Gemplus
Priority date: 2004-12-14
Filing date: 2005-11-14
Publication date: 2006-06-22
Also published as: FR2879319A1; FR2879319B1

Abstract

The invention concerns a method for positioning elementary data (b1, i1, s1) of a data structure in a storage unit organized in words of at least four bytes, comprising, dependent on the size of the next data to be positioned, determining the position (Res) to assign in storage to said elementary data based on a description of said structure in storage, and updating said description of said structure in storage. The invention is characterized in that said description is based on at least three indications (v1, v2, v4) indicating respectively the next position available in storage for placing a data of one byte in size, the next position available in storage for placing a data of two bytes in size and the next position available in storage for placing a data of at least three bytes in size.

Description

METHOD FOR POSITIONING ELEMENTARY DATA OF A DATA STRUCTURE IN A MEMORY

The present invention relates to embedded software and execution environments in a portable electronic device with a microcontroller uniting a processor and memories, such as a smart card for example.

More particularly, the invention relates to a method for positioning elementary data of a data structure in a memory.

In fact, to organize the contents of a memory, data structures representing an organization of the elementary data of a code in a particular logical structure are used. These data structures are then intended to be allocated in memory, that is to say a memory area is reserved to store this data structure, during loading and installation of the code in memory by the environment execution.

The software code itself does not contain information on how to place the elementary data of the structure in memory (order, disposition), but generally provides information on the type and size of this data. The elementary data is typically encoded on either 1 byte, 2 bytes, or multiple 4 bytes. When assigning basic data of a data structure to memory, it is necessary to respect the alignment constraints for the representation of the data in memory, which are imposed by the hardware architecture of the processor. Thus, the one-byte data can be set to any memory address, whereas the double-byte data can only be set to a memory address that is multiple of 2, and the data encoded in multiples of four Bytes can only be set to a memory address that is a multiple of 4.

Today, hardware architectures rely mainly on 32-bit memory addressing, the size of memory words being limited to 4 bytes. The following description will be made with reference to this memory word size although the invention is not limited to such memory structures.

Several conventional approaches can then be envisaged to calculate the positioning of elementary data of a data structure in memory. The following examples are based on a class data structure and will thus describe the loading of a class by an embedded virtual machine, which is the interface for translating into executable instructions by the processor of the host device object-oriented intermediate languages such as the Java pseudocode (designated bytecode in English), obtained after compilation of the Java source language.

As a reminder, a Java software is conventionally distributed in the form of a set of modules consisting of .class files. These files correspond to a compiled form of the software. Each compiled file corresponds to a data structure of class type and comprises as such the description of the elements of the class, in particular its fields, which constitute in this context the elementary data to be placed in memory for the execution of the pseudo-Java code.

The virtual machine loader is then provided to load and transform the information in the .Class file into work memory data structures, which are specific to the virtual machine and allow this virtual machine to run the software.

To illustrate the process of positioning the fields of a class when it is loaded into a memory structure according to the state of the art, that is, the next piece of pseudocode, describing a class comprising three fields of different sizes.

Class C {// the class is named ^Λ C

Byte bl; // a field named ^Λ bl 'of size 1 byte Int il; // a field named ^Λ il / of size 4 bytes

Short si; // a field named ^Λ sl 'of size 2 bytes

} The optimal size of the instances of the class is equal to the sum of the size of each of its fields, ie 7 bytes for the instances of the class ^Λ C.

FIG. 1 illustrates a zone 10 in a 32-bit memory structure, as it arises at the end of a process for storing the fields of the pseudo-code under consideration, where each field is placed at the following the other, taking into account the alignment constraints described above. Thus, for the class ^Λ C considered, the field bl, encoded on 1 byte, is positioned at the memory address 0, the field it, coded on 4 bytes, is necessarily positioned at the memory address 4 because of the constraints of alignment of the processor, and the field if, coded on 2 bytes, is then positioned at the memory address 8.

Each field of the class thus occupies the same place in memory. We realize that this solution is not at all optimal with regard to the total size of an instance of this class, which in this example occupies 12 bytes, while 5 bytes remain unoccupied (bytes appearing in white on the figure), corresponding to as much space lost in memory.

A solution for optimizing the occupation of the memory during the positioning of the fields of a class data structure class was then developed and is presented in Figure 2. This solution consists in establishing a memory card 20, allowing to memorize for each address of the memory 10, whether it is occupied or not. Initially, all the bits of the card of which initialized to 0. According to this method, the first field bl, coded on 1 byte, is positioned at the memory address 0 and the corresponding bit of the memory card for this byte is then placed to 1, indicating that this byte is now busy.

To position the next field it, coded on 4 bytes, one will traverse the memory card from its beginning until finding the next well aligned location (that is to say with an address multiple of 4), of size 4 bytes, which is available. As a result, the field is set to the starting memory address 4 and the memory card is updated. To do this, the corresponding bits of the memory card for the bytes of memory addresses 4 to 7 are set to 1, indicating that these bytes are now occupied.

Then, to position the next field if, coded on 2 bytes, we will again browse the memory card from its beginning until finding the next well aligned location (that is to say an address multiple of 2), of size 2 bytes, which is available. This location corresponds to memory addresses 2 and 3. The field if is then set to memory address 2 and the memory card is updated. To do this, the corresponding bits of the memory card for the bytes of memory addresses 4 to 7 are set to 1, indicating that these bytes are now occupied. The memory card thus provides during the process of positioning fields, a description of the data structure in memory.

We then obtain an optimal positioning of the fields of the class in the memory zone which is assigned to it. Indeed, in this example the instances of the class ^Λ C would have a size of 8 bytes, and we have only one byte of lost at the level of the occupation of the memory for an instance of this class.

This solution nevertheless has two major disadvantages. First of all, she is a consumer in memory. Indeed, it requires, when calculating the placement of the fields, to store the memory card, the latter occupying a quantity of significant memory, since proportional to the size of the memory structure of which it reproduces the cartography. This method may therefore be unsuitable for implementation in constrained environments in memory, such as smart cards for example, where optimal use of the memory resource is a strong requirement.

Moreover, in this same context, to be able to ensure the notion of class inheritance, the mapping of the memory must be kept in memory. In fact, when the virtual machine receives a child class from an already treated parent class, it must take into account, for the calculation of the positioning of the fields of the child class, the position of the fields of the mother class: they also exist in the girl class and are positioned in the same place.

Another disadvantage of this solution concerns the inefficiency in terms of execution time of the calculation of positioning of the fields. Indeed, this method requires to browse the memory card from its beginning as many times as there are fields to place in the memory structure. This process can become highly penalizing in the presence of a large number of fields to place, especially in embedded environments, usually with low computing resources.

The aim of the invention is to solve one or more of these disadvantages, by proposing a method making it possible to obtain optimal positioning in memory of elementary data of a data structure, while being efficient in terms of memory consumption and time of storage. calculation. The invention thus relates to a method for positioning elementary data of a data structure in a memory organized in words of at least four bytes, comprising, depending on the size of the next data to be positioned, the determination of the position to allocate in memory to said elementary data item according to a description of said structure in memory, and updating said description of said structure in memory, characterized in that said description is based on at least three indices respectively indicating the next available memory location for placing one byte size data, the next available memory location for placing two byte size data, and the next available memory location for placing a data size of at least three bytes.

According to one embodiment, the determination of the position in memory of the elementary data item to be set according to the description of the data structure in memory, consists in assigning to said position the current value of the index corresponding to the size of the data element. the given data.

According to one embodiment, the update of the description of the data structure in memory consists in assigning new values to said indices as a function of their relative positions, so that said updated values respectively describe the new position in the smallest available memory where a next elementary data of size one byte, two bytes, or at least three bytes can be positioned. The method according to the invention is advantageously applied to the positioning in memory of the fields of a class of a software code compiled into an object-oriented intermediate language, the class possibly being a class inheriting from another class.

The method according to the invention also advantageously applies to the positioning in memory in an execution stack of variables of a set of local variables of a function.

The invention also relates to a charger for a software code compiled into an object-oriented intermediate language intended to be loaded into a portable electronic device, characterized in that it is capable of being stored in a non-volatile memory of the device for the implementation of the method according to the invention.

The invention also relates to a portable electronic device comprising a non-volatile memory storing the charger as just described.

Preferably, this device is a smart card.

Other characteristics and advantages of the present invention will emerge more clearly on reading the following description given by way of illustrative and nonlimiting example and with reference to the appended figures in which:

FIG. 1 is a schematic representation of a memory zone in a 32-bit memory structure, in which the fields of a class have been positioned according to a method of the prior art; FIG. 2 is a schematic representation of said memory zone, in which the fields of a class have been positioned according to an optimized method of the prior art; - Figure 3 is a flowchart illustrating the implementation of the method according to the present invention.

According to the invention, the method for positioning elementary data of a data structure in memory is based on a particular description of the structure in memory. This description is based on the calculation and updating of three indices, v1, v2 and v4, instead of keeping in memory the memory card of the solution of the prior art described above. The indices v1, v2 and v4 are provided to respectively describe the next position or available memory address (and therefore well aligned) where a data coded on 1 byte can be placed, the next available memory address where a data coded on 2 bytes can be placed and the next available memory address where a data coded on 3 bytes, 4 bytes or more (in this case, one will round the size of the data to the multiple of 4 superior) could be placed. Because of the alignment constraints, data encoded on 3, 4, 5 bytes and more can be aligned only in multiples of 4 in memory address.

The three indices v1, v2 and v4 required for the implementation of the positioning method according to the invention can for example be coded each on 2 or 4 bytes. They then occupy a maximum of 6 or 12 bytes in memory. The use of such indices therefore has the advantage of consuming only a fixed amount of memory, independent of the size of the memory structure to be described.

The flowchart of FIG. 3 illustrates the implementation of the method of the invention based on the use of the three indices v1, v2 and v4.

Let data elements of a data structure of sizes 1, 2 and multiples of 4 bytes to be stored in memory. The three indices v1, v2 and v4 are initialized to zero at the beginning of the process and we give as input the size of the next data to be stored in memory.

More precisely, the indices are initialized to zero if we are addressing the beginning of the data structure, otherwise the indices are initialized with the structure start address in the memory. The initialization of the indices only occurs the first time that we have to position an elementary datum in the structure. Subsequently, the indices retain their current values as the data structure evolves in memory.

In El, we look at whether the size of the data is equal to 1. In this case, in E2, the position (named "Res") that is allocated to this datum in memory is given by the current value of the index v1. . The position of the data in memory is in fact determined by the current value of the index corresponding to the size of the data considered. The values of the three indices must then be updated according to the following process. In E3, we see if v1 is equal to v2. If this is not the case, we go to E4 where the new value of the updated index v1, named nvl, takes the current value v2, the new value of the index v2 updated, named nv2, remains equal to the current value v2, and the new value of the index v4 updated, named nv4, remains equal to the current value v4.

On the other hand, in the case where the equality tested in E3 is verified, one goes to E5, where the value of the index v1 is updated. This new value nvl of the index vl updated takes in this case the value vl + 1. To update the values of the other indices v2 and v4, we then look at E6 if v2 is equal to v4. If this is not the case, we go to E7, where the new value nv2 of the updated index v2 takes the current value v4, and the new value nv4 of the index v4 updated, remains equal to the current value v4. On the other hand, in the case where the equality tested in E6 is verified, one goes to E8, where in this case, the new value nv4 of the index v4 updated takes the value v4 + 4, and the new value nv2 The updated v2 index takes the value v2 + 2.

The three indices are thus updated so that they each correspond to the newest available small memory address where a next datum respectively of size 1, 2, or multiple of 4 bytes can be positioned. This updating of the indices is advantageously deduced from a simple analysis of their relative positions. Similar to what has just been described for a data item of size 1, if, in E9, the next data to be placed is of size 2 bytes, the position Res which is allocated in ElO to this data in memory is given, according to the principle of the invention, by the current value of the index v2. The position allocated to a data item of size 2 in memory is in fact determined by the current value of the index corresponding to the size of the data item, namely in this case, v2.

Once the positioning of the data considered has been determined, the values of the three indices v1, v2 and v4 must then be updated.

To do this, we look at ElI if v2 is equal to v4. If this is not the case, we go to E12, where the new value nv2 of the updated index v2 takes the current value v4, and the new value nv4 of the index v4 updated, remains equal to the current value v4. On the other hand, in the case where the equality tested in ElI is verified, one goes to E13, where in this case, the new value nv4 of the index v4 updated takes the value v2 + 4, and the new value nv2 The updated v2 index takes the value v2 + 2.

For the update of the index vl, we go to E14, where we check the equality vl = v2. If this is the case, in E15, the new value nvl of the updated index vl takes the value nv2 of the index v2 that has just been updated, otherwise, in E16, the new value nvl of the index vl update keeps the current value vl.

Finally, if the next piece of data to be placed has a size of 3 bytes or more, the placement Res which is allocated in E17 to this piece of data in memory is given, according to the principle of the invention, by the current value of the index v4. It should be noted that if the size of the data considered is greater than 4 bytes, its size will be rounded up for index positioning and update calculations to the multiple of 4 immediately greater than or equal to

(Thus, a data coded on 3 bytes will see its size rounded to 4 bytes, a data coded on 4 bytes will see its size remained to 4 bytes, a data coded on 5 or 6 or 7 or 8 bytes will see its size rounded to 8 bytes , etc.).

Thus, the new value nv4 is updated to E18 and takes the current value v4 to which is added the size of the data considered, rounded to the multiple value of 4 immediately greater than or equal to.

As for the updating of the indices v1 and v2, we go to E19, where we check the equality v4 = v2. If the two indices v4 and v2 have different values, the update is carried out as follows in E20 where the new updated value nv2 remains unchanged and keeps the current value v2, and the new updated value nvl remains unchanged and keep the current value vl. On the other hand, if the equality in E19 is verified, the new value nv2 of the index v2 is updated to E21 and takes the value nv4 which has just been updated. Then, the updating of the index v1 consists in checking in E22 the equality v1 = v2. If this is the case, in E23, the new value nvl of the index vl updated takes the new value nv2 of index v2, otherwise, in E24, the new value nvl of index vl updated keep the current value vl. Thus, the method of the invention simply needs as input the size of the next elementary data element of the data structure to be placed in the memory and the description of this structure in memory, which is provided by the three indices v1, v2 and v4, respectively indicating the next available memory address and well aligned to place a data of size 1, the next available memory address and aligned well to place a data of size 2 and the next memory address available and well aligned to place a data multiple size of 4. Then we obtain the position in memory

(Res) which must be allocated to the data to be placed and the updated description of the structure in memory, which is deduced from a simple analysis of the relative positions of the indices.

The method for positioning a piece of data in memory based on the three indices v1, v2 and v4, which has just been described, is more particularly intended to respond to the alignment constraints inherent to 32 bit type memory structures, where the Memory word size is therefore 4 bytes. However, it could be envisaged, without departing from the scope of the invention, to use more indices if the hardware alignment constraints were different. This may be the case, for example, with a memory organized into 8-byte (64-bit) words where the alignment rules require that the 1-byte data can be positioned only at addresses that are multiples of 1, the data of 2 bytes can only be set to multiple addresses of 2, the 3 and 4 byte data can only be set at multiple addresses of 4 and the other size data can only be set at multiple addresses of 8. In this example, 4 indices to be able to fully describe the structure in memory and modify accordingly the updating rules of the indices in the algorithm described in FIG.

In general, the method of positioning data in memory according to the invention is intended to apply to all the execution environments where the memory must be organized and to store elementary data of variable sizes in the memory in an optimized manner. terms of memory occupancy, taking into account hardware alignment constraints.

Thus, the method according to the invention is applicable to the calculation of the positioning of the fields of a data structure in general and, for example, to the computation of the positioning of the fields of a class of a software code compiled into intermediate oriented language. object, when loading the class into working memory by a loader of an embedded virtual machine. The method of the invention is more particularly advantageous in the case where the class to be loaded is a class that inherits from another class. In fact, when the virtual machine receives a child class from a parent class already processed, it must take into account, for the calculation of the positioning of the fields of the child class, the position of the fields of the mother class whose daughter class inherits . For this purpose, the three indices vl, v2 and v4 already used when calculating the positioning of the parent class fields are added to the class information, so that they can be reused to calculate the positions of the child class fields when it is loaded, which are then added to the fields of the mother class already positioned.

The method of the invention thus typically applies to the Java Card (registered trademark) or .Net (registered trademark) platform. Also, another application of the method according to the invention relates to the positioning of a set of local variables of a function in an execution stack, this set of local variables forming a data structure. Indeed, in the same way that each field is assigned a position in a class instance in memory, the local variables of a function stored in the stack must be assigned a position relative to the position of the stack at the same time. input of the function.

Claims

A method of positioning elementary data (b1, h1, f1) of a data structure in a memory organized in words of at least four bytes, comprising, depending on the size of the next data to be set, determining the position

(Res) to be allocated in memory to said elementary data item according to a description of said structure in memory, and the update of said description of said structure in memory, characterized in that said description is based on at least three indices

(v1, v2, v4) respectively indicating the next available memory location to place one byte size data, the next available memory location to place a two byte size data item and the next available memory location to place a data item. size at least three bytes.

2. Method according to claim 1, characterized in that the determination of the position in memory of the data item to be placed according to the description of the data structure in memory, consists in assigning to said position (Res) the current value. of the index (v1, v2, v4) corresponding to the size of the data considered.

3. Method according to claim 1 or 2, characterized in that the update of the description of the data structure in memory consists of assigning new values to said indices (v1, v2, v4) according to their relative positions, so that said updated values (nv1, nv2, nv4) respectively describe the new position in the smallest available memory where a next elementary data of size one byte, two bytes, or at least three bytes may be positioned.

4. Method according to any one of the preceding claims, characterized in that it consists in positioning in memory fields of a class of a software code compiled into an object-oriented intermediate language.

5. Method according to claim 4, characterized in that the class is a class inheriting from another class.

6. Method according to any one of claims 1 to 3, characterized in that it consists in positioning in memory in an execution stack, variables of a set of local variables of a function.

A charger for a software code compiled into an object-oriented intermediate language intended to be loaded into a portable electronic device, characterized in that it can be stored in a non-volatile memory of the device for implementation. process according to any one of claims 1 to 5.

Portable electronic apparatus comprising a non-volatile memory storing the charger of claim 7.

9. Apparatus according to claim 8, characterized in that this apparatus is a smart card.