FR2791444A1 - Data processing system automated memory allocation in virtual machine applications; uses decomposition graph applied automatically on element to forms at least elementary parts having size lower or equal to base memory - Google Patents

Abstract

A graph of decomposition is automatically applied to an element to form at least elementary parts (P1,P2,P3) having a size lower or equal to the base memory which stores every elementary section (P1,P2,P3) in a completely available memory block. All memory blocks (BM2,BM4,BM6) allocated for this request are combined in a graph of blocks identical to the graph of decomposition. An Independent claim is included for: (a) a device for an automatic allocation of a memory area

Description

Method and device for automatically managing the memory allocations of a

main RAM

  The invention relates to the automatic management of allocations

  memory of a main RAM and more particularly the automatic recovery of free memory space in a memory that has been fragmented during the execution of a program implemented in a digital data processing system, for example a processor or a virtual machine,

accessing said memory.

  Fragmented memory is an unused memory space that can not be used by the data processing system to satisfy a memory allocation request. More precisely, the fragmented memory due to fragmentation, called external, is an available part of the memory space but which consists of

  non-contiguous segments, so that a request for allocation-

  memory larger than the largest available segments, can not be satisfied even if the total size of the

  fragmented memory would be sufficient to satisfy the said request.

  This external fragmentation therefore leads to a loss of memory capacity. The percentage of memory capacity thus lost due to external fragmentation can be very high, and thus only a few items stored in memory can prevent large memory space from being used to satisfy queries.

  large memory allocation.

  A conventional way to overcome the drawbacks of external fragmentation is to implement an automatic recovery of free memory spaces (called "garbage collector" or "garbage collector" in English) able to move the stored segments to certain places of memory for store them at other locations to group free memory segments together to form a continuous block available for any memory-allocation requests

  continuous whose size does not exceed that of the memory block thus released.

  This being so, to avoid updating all the references of an element that has been moved within the memory space, specific cells or "handles" (English handles) are used and all the accesses to the segments of memory are made via such a specific handle. However, this has the effect of doubling the number of memory accesses thus imposing a duration

  more important execution for the program.

  Moreover, moving elements in the memory space, and consequently modifying the addresses of these elements significantly complicates the optimization of the compilers since the determination of the addresses for these elements, which are carried out in a compilation code or code- machine, may become invalid during the implementation of the automatic recovery module of

memory space.

  In addition, moving large items, such as large tables, causes unpredictable pauses in the execution of the program, pauses whose duration depends on the size of the elements and which are not compatible with a real-time system,

  as for example an onboard computer.

  The invention aims to provide a solution to these problems.

  The object of the invention is to eliminate any external fragmentation of memory, without the need to move the elements stored in memory. Another object of the invention is to overcome the use of specific "handles" (handles) and therefore to avoid providing additional memory capacity for

  the implementation of such handles.

  The invention also aims to propose an automatic memory management that is compatible with a time processing

real.

  The invention therefore proposes a method for automatically managing the memory allocations of a main random access memory by a digital data processing system, in particular a processor or a virtual machine, executing a program implemented in said system, for example a virtual machine. using the JAVA language

  (registered trademark) well known to those skilled in the art.

  According to a general characteristic of the invention, the memory space of the main random access memory is partitioned into at least one group composed of several memory blocks of identical and fixed memory size during at least one time period of said execution. And, in the presence of a memory allocation request during said time period for the storage of an element in said memory, a decomposition graph is automatically applied to said element so as to break it down into at least a part of the memory. elementary memory having a size less than or equal to said memory size, and each elementary part is stored in a fully available memory block, all the memory blocks allocated for this request being connected in accordance with a block graph identical to the

graph of decomposition.

  In other words, the memory is divided into blocks of equal size. Small memory allocation requests can be satisfied by allocating a single memory block while larger size requests require multiple blocks. However, the memory blocks of the memory space never move and any fully available block can be used for any memory allocation request, regardless of the size of the request. Thus, due to the automatic use of identical memory blocks having a fixed size, no external fragmentation of the memory occurs, and any available memory block is always directly usable for

new memory allocations.

  Compilers can thus optimize and reuse address calculations since the addresses of the memorized elements

never change.

  Moreover, such a memory management method is compatible with execution of a real-time program since no element stored in the memory is mobile. There are no more problems due to long pauses caused by moving large elements stored in memory

  to gather available memory segments.

  Moreover, since the automatic memory allocation management device only works on blocks of identical size, it becomes easy to implement and verify. This is particularly interesting when certifications are required

  for systems where security is particularly important.

  For the purposes of the present invention, the expression "decomposition graph" or "block graph" must be taken in a very broad sense. Indeed, the most common type of memory access is access to a small element. In this case, these accesses can be made directly using a single available memory block of fixed size. More precisely, when the size of the element is less than or equal to a predetermined threshold, the decomposition graph retains the element in its entirety, this element then being stored in its entirety in a single memory block

totally available.

  On the other hand, for large elements in particular, the element is decomposed into several elementary parts that are respectively stored in several available memory blocks, some of the memory blocks of the block graph containing link information for designating automatically the next block in the

graph.

  The decomposition graph can simply be a string.

  Such a string can be applied for JAVA type objects.

  Alternatively, the decomposition graph can be a tree. This is particularly so when the item to be stored

is a painting.

  In some applications, we can partition the space

  memory in several groups of memory blocks. All blocks-

  memory of a group have the same fixed size for at least

  time period of program execution. However, the size

  block memory of a group is different from the memory size of the

  blocks from another group. We then store an element in blocks

  memory belonging to these groups. In this respect, an element can be stored in memory blocks belonging to one and the same group

or to different groups.

  It is also possible to modify the memory size during the execution of the program, the new memory size remaining identical and fixed for all the memory blocks of each group for at least one other time period of the execution of the program. The subject of the invention is also a device for automatically managing the memory allocations of a main random access memory, comprising, besides said memory, a digital data processing system, for example a processor, a virtual machine, a compiler or a interpreter, able to access the memory during the execution of a program implemented in said system. According to a general characteristic of the invention, the memory space of the memory is partitioned into at least one group composed of several identical memory memory blocks and fixed for at least one time period of said execution. The system comprises means capable, in the presence of a memory allocation request during said time period for storing an element in said memory, to automatically apply a decomposition graph on said element so as to decompose it. in at least one elementary part having a size less than or equal to said memory size. The system also comprises means capable of storing each elementary part in a memory block that is totally available from the memory, all the memory blocks allocated for this request being connected in accordance with a block graph identical to the decomposition graph. According to a preferred embodiment of the invention, the system is a virtual machine, for example a JAVA virtual machine, comprising a suitable compiler, in the presence of an instruction

  memory allocation request, to automatically generate the code-

  machine making it possible to access said memory in accordance with the audit

  block or decomposition graph.

  In other words, the decomposition of the elements as well as the construction of the block graph for the memory accesses, are

  completely transparent to the user.

  Other advantages and characteristics of the invention will become apparent from the detailed examination of embodiments and implementations, in no way limiting, and the accompanying drawings, in which: FIG. 1 schematically illustrates an embodiment of FIG. a means for recovering space available in a memory, belonging to the prior art, - Figure 2 very schematically illustrates a mode of

  implementation of an automatic allocation management system-

  memory according to the invention, allowing implementation of the method according to the invention, and - Figures 3 to 5 illustrate implementations of the method according to the invention for storing elements of different types

  and large in a memory according to the invention.

  In FIG. 1, the reference MM designates a main random access memory in which elements or objects OB1, OB2 and OB3 are stored at different addresses. During the execution of a program implemented in a processor accessing said memory, the segments SM1, SM2 and SM3 of the memory space MM, which were previously assigned to other objects, were released. The Garbage Collector (Garbage Collector) retrieval algorithm then detects, in a manner known to those skilled in the art, the available segments SM1-SM3 and moves the OB2 and OB3 objects to form from the fragmented SM1 segments. , SM2 and SM3 a continuous available memory segment SM4, illustrated on the right-hand side of Figure 1, segment SM4 which is then

  able to receive a new large object OB4.

  According to the invention, as illustrated more particularly in FIG. 2, the memorized objects are not moved so as to liberate memory space, but, as will be seen in more detail now, the main RAM memory MM is partitioned into a set of memory blocks BMi of identical size and fixed, and each block BMi totally available can be used for a memory allocation

  of any size by the SYS data processing system.

  This SYS data processing system can be a processor or a virtual machine. A virtual machine is an abstract processing machine that, in a manner analogous to a real processing machine, has a set of instructions and uses different areas of memory. In general, the implementation of a virtual machine can be performed in a hardware way, for example by a hardware processor, or in a software way by implementations of compiler or interpreter, or in a mixed software and hardware way. Each virtual machine instruction defines a specific operation that must be performed. The virtual machine does not need to understand the computer language that is used to generate the virtual machine instructions or the implementation of levels below the virtual machine. Only a particular format of virtual machine instructions should be understood. For example, virtual machine instructions can be JAVA virtual machine instructions. Each JAVA virtual machine instruction includes one or more bytes that encode information identifying instructions, operands

  and any other information required.

  It is now assumed in the example which will be described that the SYS system is a 32-bit JAVA virtual machine which comprises software means MP for partitioning the memory MM, MD means for detecting the memory blocks BMi available (these means detection means being conventional structure means and known to those skilled in the art) as well as MG means, which will be discussed in more detail below on the function, and whose role is to perform a decomposition of large elements. front size

be stored in memory MM.

  All these means MP, MD and MG are made in software. It is assumed here that each BMI memory block has a size

  fixed 16 bytes ie 4 machine words of 4 bytes each.

  It is also assumed, with particular reference to FIG. 3, that during the execution of the program implemented in the SYS system, objects OB1, OB2, OB4 and OB7 occupy the memory blocks BM1, BM3, BM5 and BM7

  while the MD detection means have detected that the

  memory BM2, BM4, BM6, BM8, BM9 and BM10 were available

  for a possible other memory allocation.

  It is also assumed, with reference more particularly to FIG. 4, that an object OB6 composed of 7 fields

  or 4-byte words F1-F7 must be stored in the MM memory.

  The means MG then automatically apply a decomposition graph on the object OB6 so as to decompose it in three

elementary parts P1, P2, P3.

  The first part P1 comprises a first word comprising the type TY of the object, followed by the first two words of the object OB6, and a final word LK1 containing link information. This link information links the first elementary part P1 to the second elementary part P2 whose first three words contain the other three words F3, F4 and F5 of the object OB6 and whose fourth word contains a link information LK2 which links this second part to the third elementary part P3 containing the

  last two words F6 and F7 of object OB6.

  The means MG then store the three parts P1, P2, P3 respectively in the three memory blocks

available BM2, BM4 and BM6.

  Blocks BM2, BM4 and BM6 are not contiguous blocks and are organized in a block graph similar to the decomposition graph of object OB6. More particularly, in the present case, the BM2, BM4 and BM6 blocks are chained, the last word or field of each of the first two blocks is used to designate the next block in the chain. More precisely, the word LK1 contains for example the address of the first word of the block BM4 while the word LK2

  contains the address of the first word of block BM6.

  Note here that the last two words of block BM6 are not busy. That being the case, according to the invention, these last two words can not be used for another memory allocation so long.

  all words in the block will not be declared available.

  For the implementation of the automatic management of memory allocations, it is necessary to have information indicating where reference type information and links in the blocks are stored (indeed some fields of

  objects can also contain references to other objects).

  This information can be stored in a one-bit vector which conventionally exists in parallel with the main memory MM and which provides one bit per word. This bit indicates whether the corresponding word is reference or link type information or not. Thus, as a guide, a logical value 1 will mean that the corresponding word is

  link or reference information.

  The code that is required to access the object thus decomposed is automatically created by the interpreter or the compiler of the virtual machine, this decomposition of the memorized object remaining transparent to the user. Only the address of the first block storing

  the object is needed to access the object in its entirety.

  Of course, for small objects, whose fields only require, for example, 8 bytes of memory, the complete object can

  be stored entirely in a single block of 16 bytes.

  Arrays are particular types of elements. Although it is possible to use a tree of the type string to break down and store tables in the memory, it is preferable, for large tables, to use a decomposition of the tree type as illustrated more particularly in the figure.

  5. This allows faster access to the table data.

  In this FIG. 5, a TB array of the JAVA type containing 16 words of data D1 to D16 is broken down into six elementary parts.

P1 to P6.

  More specifically, the part P1 is the leading part of the table containing TY information relating to the type of the stored item. LH information relating to the length of the table is stored in the second word of the block. DH information relating to the depth of the table is stored in the third word of the block, and finally, a link information LK1 for pointing the second part P2 of the decomposed table, is stored in the last word of the block. The four words of the second part P2 respectively contain four links information LK2-LK5 respectively allowing access to the four parts P3 to P6 containing the

data D1 to D16 of the table.

  These parts P1 to P6 are respectively stored in the fully available memory blocks BM2, BM4, BM6, BM8, BM9 and BM10. The words LK2, LK3, LK4 and LK5 respectively contain

  the addresses of memory blocks BM6, BM8, BM9 and BM10.

  To access the elements of such a table, it is therefore necessary to traverse the tree until the end blocks (or "leaf blocks") containing the desired elements have been reached. Of course, this tree structure is not visible to the user of the virtual machine, and the interpreter or compiler automatically generates the code required to handle the

access to this table.

  As an indication, the required code may use a short loop to traverse the depth of the tree until the data of a leaf block can be reached. This can easily be implemented in machine code. By way of example, the pseudo-code C for such a loop is the following: block * ptr = & array. data; for (int i = array. depth; i> o; i -) t ptr = ptr [index / node-width Ai% node- width]; } data = ptr [index% node-width]; The node-width coefficient is a constant power of 2 indicating the number of words at a node of the tree (4 in the example described). Of course, those skilled in the art will be able to adjust the code if the size of the elements stored in the table is different from the size of the

machine word.

he

Claims (9)

  1. A method for automatically managing the memory allocations of a main random access memory by a digital data processing system executing a program implemented in said system, characterized by partitioning the memory space of the main random access memory ( MM) in at least one group composed of several memory blocks (BMi) of identical and fixed memory size during at least one time period of said execution, and in the presence of a memory allocation request during said period time for storing an element (OB6) in said memory, a decomposition graph is automatically applied to said element so as to decompose it into at least a part   (P1, P2, P3) having a size less than or equal to said size   memory and stores each elementary part (P1, P2, P3) in a block   fully available memory, all memory blocks (BM2, BM4, BM6) allocated for this request being connected in accordance with a block graph   identical to the decomposition graph.   2. Method according to claim 1, characterized in that when the size of the element is less than or equal to a predetermined threshold, the decomposition graph retains the element in its entirety, which is then stored in its entirety. in one   fully available memory module (BMi).   3. Method according to claim 1, characterized in that the element is broken down into several elementary parts which are respectively stored in several available memory blocks, some of the blocks of memory of the block graph containing link information. (LKi) to automatically designate the next block in the graph.   4. Method according to claim 3, characterized in that   the decomposition graph is a string.   5. Method according to claim 3, characterized in that   the decomposition graph is a tree.   6. Method according to one of the preceding claims,   characterized by partitioning the memory space (MM) into several groups of memory blocks, all the memory blocks of a group having the same memory size fixed for at least said time period, the memory size blocks of a group being different from the memory size of the blocks of another group, and by the fact that an element is stored in memory blocks belonging to these groups.   7. Method according to one of the preceding claims,   characterized by the fact that the memory size is modified during the execution of said program, the new memory size remaining identical and fixed for all the memory blocks (BMi) of each group for at least one other time period of the execution of the program. 8. Device for automatically managing the memory allocations of a main random access memory, comprising in addition to said memory, a digital data processing system able to access the memory during the execution of a program implemented in said system, characterized by the memory space of the main random access memory (MM) is partitioned into at least one group consisting of several memory blocks (BMi) of identical and fixed memory size for at least one time period of said execution, and in that the system (SYS) comprises means (MG) capable, in the presence of a memory allocation request during said time period for the storage of an element in said memory, to automatically apply a graph decomposing on said element so as to decompose it into at least one elementary part having a size less than or equal to said memory size and   means (MG) able to store each elementary part in a block   memory completely available, all memory blocks allocated for this request being connected in accordance with a graph of   blocks identical to the decomposition graph.   9. Device according to claim 8, characterized in that the system (SYS) is a virtual machine having a compiler adapted, in the presence of a memory allocation request instruction, to automatically generate the machine code for accessing said memory in accordance with said block graph or decomposition.