JP2000259425A - Reducing method for character string storage area - Google Patents

Abstract

PROBLEM TO BE SOLVED: To reduce memory capacity required for holding a character string group by registering the character data of character strings in one string table and expressing each character string by pairing a start position on the string table and a character string length. SOLUTION: In the case of storing a character string group including plural character strings, when one character string ('java/lang/String') is the partial character string of the other character string ('(Ljava/lang/Object;)Ljava/lang/ String;'), one string table 10 is prepared by connecting plural character strings. By storing a leading address 12b of the partial character string in the string table 10 and a character string length 14b of the partial character string in the string table 10, the area for storing respective characters constituting the partial character string ('java/lang/String') can be unnecessitated.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a method for reducing a character string storage area, and more particularly to a method for reducing a storage area for character strings included in a constant pool section in a Java language class file.

[0002]

2. Description of the Related Art Conventionally, when a character string group is stored in a memory, the memory required to store each character constituting the character string and the head position of the character string are simply represented for each character string. The memory required to store the address is allocated.

[0003] At present, the Java language has attracted much attention because a program independent of a machine type can be created. FIG.
Shows the execution procedure of a program written in the Java language. Java programs written in the Java language (.jav
a file) is converted to a class format file (.class file) by the byte compiler. cl
The file in the ass format is composed of an instruction execution unit called a bytecode, and a unit holding information necessary for execution of an instruction such as a constant pool.
The Java virtual machine reads the file in the class format and sequentially executes necessary bytecodes according to a predetermined procedure.

FIG. 4 shows a Java language development kit Java Devel.
The part that holds the character string of the constant pool part is extracted and displayed from the class file of the java.lang.Object class in the class library included in the opment Kit (JDK) version 1.1.5. Conventionally, for each of these character strings, the data is held using a set of character data constituting each character string and a start address of the character string in a memory space.

More specifically, when implemented on a 32-bit microprocessor, in order to store a character string having the number of characters n, n bytes for characters constituting the character string, 4 bytes for the head address, Requires a total of (n + 4) bytes of memory.

In practice, each character string has a hash value (2 bytes) for speeding up the comparison of the character strings. Taking this into consideration, a character string already registered in the hash table requires 6 bytes, and a character string other than that requires (n + 6) bytes of memory.

Referring to FIG. 5, “(Ljava / lang / Object;) Lj
ava / lang / String; ”and“ java / lan
The following describes an example in which a character string 50b “g / String” is stored.

Conventionally, the character string 50a itself has 38 bytes,
4 bytes at the start address 52a of the character string 50a, 2 bytes at the hash value 56a of the character string 50a, and similarly, 16 bytes at the character string 50b itself, 4 bytes at the start address 52b of the character string 50b, and hash of the character string 50b. Value 56
b requires 2 bytes. That is, the character strings 50a and 5
For storing 0b, a total of 66 bytes of memory is required.

[0009]

[Problems to be solved by the invention] However, class
If a character string group including a large number of character strings, such as a constant pool part in a file, is stored in a memory by a conventional method, a large amount of memory is consumed.

[0010]

A first feature of the present invention is as follows.
When storing a character string group including a plurality of character strings,
When one character string is a partial character string of another character string, a plurality of character strings are concatenated to create one concatenated character string,
A head address of the partial character string in the concatenated character string;
A method of reducing a character string storage area by storing a character string length of the partial character string in the concatenated character string, thereby eliminating an area for storing each character constituting the partial character string.

A second feature of the present invention is that the character string group is
This is a method of reducing the character string storage area that is a constant pool part in the class file.

"Partial character string" refers to a character string that appears as a part of another character string.

The “constant pool section (cp)”
This area stores constants that are referenced inside the class file. Variable length array, numbered from zero.

With this configuration, it is not necessary to store each character constituting the partial character string for a partial character string that matches a part of another character string.
The storage area can be reduced.

When a program written in the Java language is converted into a class file format by using a compiler, due to the nature of the Java language and the class file format, there are many substrings of other character strings in the constant pool section. Will be done. Instead of saving the character string data as it is as in the past, instead of saving the character string data as is, the method of saving only the head address on the concatenated character string and the length of the character string allows the character string to be It is possible to reduce the memory capacity required for storing the constituent characters.

[0016]

Embodiments of the present invention will be described below with reference to the drawings. FIG. 1 is a diagram for explaining a character string storage method according to the embodiment of the present invention.

As shown in FIG. 1, a character string group including a plurality of character strings (a constant pool in FIG. 4) is stored, and one character string ("java / lang / String") String ("(Ljava / lang / Object;) Ljava / lang / Strin
g; "), a plurality of character strings are concatenated into one string table (concatenated character string) 10
Is created, and the start address 12b of the partial character string in the string table 10 and the character string length 14b of the partial character string in the string table 10 are stored, so that the partial character string ("java / lang / String") is stored. ) Can be omitted.

As shown in FIG. 4, when a program (.java file) written in the Java language is converted into a class format file (.class file) using a byte compiler, many partial character strings exist in the constant pool portion. I do.

For example, a descriptor of a method is a character string holding information on arguments and return values of the method.
This usually contains the class name of the argument or return value as a substring of another string. As is clear from FIG. 4, these class names also exist as other items in the constant pool section.

Therefore, the property that partial character strings frequently appear is used. Instead of holding individual character strings separately as in the prior art, that is, allocating memory to each of 50a and 50b in FIG. 5, as shown in FIG. (Concatenated character string) 10 and each character string is referred to by the start position address 12a or b (4 bytes) on the string table 10 and the character string length 14a or b (1 byte). Remember.

In the present embodiment, the hash value 16a or 16b (2 bytes) is also held in order to speed up the comparison and determination of character strings. No value is required.

Thus, when the character string to be recorded (50b in FIG. 5) exists in the string table 10 as a partial character string in another character string (50a in FIG. 5),
With respect to such a character string to be recorded, it is not necessary to add a new character string to the string table 10. With the start address 12b of the character string and the character string length 14b, the storage of the character string corresponding to the recording target character string 50b in FIG. 5 is completed,
It is possible to save a 16-byte memory area required for storing each character constituting the character string 50b.

When comparing FIG. 1 with FIG. 5, the storage area for character string lengths 14a and 14b is increased by 2 bytes in FIG. 1, but the storage area for character string 50b is increased. Since the area is reduced by 16 bytes, the storage area of 14 bytes is reduced.

When storing a non-partial character string, that is, a character string that is not registered in the string table 10, assuming that the character string length is n, (n + 7) bytes are required, and the storage area is not reduced.

In this embodiment, since the character string length is held by one byte, a partial character string whose character string length does not exceed 255 characters is used for the leading address 4 bytes.
The storage of the character string is completed with a total of 7 bytes including the byte and 2 bytes for the hash value, and the storage area can be reduced.

However, since a character string length of 256 characters or more cannot be represented by one byte, the character string length field is set to 0 to make the character string length unknown. Then, instead of specifying the character string length, a null byte is added at the end when a character string is added to the string table 10. That is, instead of specifying the end of the character string by the distance from the start address, the end of the character string is specified by the position of the null byte. According to this countermeasure, the memory capacity of the partial character string, which is an advantage of the present invention, cannot be saved. However, this countermeasure is how to handle an exceptional case that occurs when the character string length is held at 1 byte. But in general Java
There are few problems because a character string of 256 characters or more is rarely included in the class file, and it is rare that the character string is a partial character string.

FIG. 2 shows a specific processing procedure. First, Ja
When the va virtual machine reads the class file, it extracts all of the constant pool units having a character string as a value (step S1), and sets the combined result to N (step S2).

In step S3, it is determined whether or not N is an empty set. If N is an empty set, the process ends. If N is not an empty set, the character string having the longest length is extracted from the character strings included in N, set to n (step S4), and set to L for the length of the character string n (step S5).

In step S6, it is determined whether or not L is greater than 255. If L is greater than 255, a null byte is added to the end of n (step S7), 0 is inserted into L (step S8), and the process proceeds to step S9. L is 2
If not greater than 55, the process proceeds from step S6 to step S9.

In step S9, the string table S
It is determined whether or not there is a character string matching n.
If there is no character string that matches n in the string table S, n is linked to the end of the string table S (step S10), and the process proceeds to step S11. If a character string that matches n exists in the string table S, the process proceeds from step S9 to step S11.

A set consisting of the start position (head address) of n and the character string length L of n is recorded in the corresponding item of the constant pool section (step S11), and n is removed from N (step S12). Hereinafter, each step is repeated until N becomes an empty set.

When the character strings of the constant pool shown in FIG. 4 are stored in the conventional manner by storing the character data of all the character strings and their addresses, a total of 95 characters is stored.
Although 5 bytes of memory are required, this is 877 bytes when implemented with the technique of the present invention, saving about 8% of memory capacity.

In an actual implementation of a Java virtual machine, a memory capacity is often secured in accordance with a word boundary for speeding up. Since the word size is 4 bytes in the 32-bit architecture, the memory capacity required in consideration of the word boundary is the case where there is a character string length entry (7 bytes) or not (6 bytes).
Bytes) are also 8 bytes, eliminating the disadvantage of adding a character string length entry.

When the memory capacity required for the character string group in the constant pool shown in FIG. 4 is calculated in the case where the memory capacity is secured in accordance with the word boundary, when the character string length entry is added (the present invention), 921 bytes are obtained. And 104 in the case of only the hash table (conventional method)
This saves about 12% of memory capacity compared to 3 bytes.

Regardless of whether or not the memory capacity is secured in accordance with the word boundary as described above, a string table is created, and a partial character string is managed by the address in the string table and the character string length. Thus, the memory capacity can be saved.

[0036]

According to the present invention, character data of a character string is registered in one string table, and each character string is represented by a set of a start position on the string table and a character string length. Memory capacity can be reduced.

[Brief description of the drawings]

FIG. 1 is an exemplary view for explaining a character string storage method according to an embodiment of the present invention.

FIG. 2 is a flowchart for explaining a processing procedure of a character string storage method according to the embodiment;

FIG. 3 is a diagram for explaining an execution procedure of a program written in the Java language.

FIG. 4 is a view for explaining a character string group of a constant pool part in a class file of a Java.lang.Object class.

FIG. 5 is a diagram for explaining a conventional character string storage method.

[Explanation of symbols]

 10 String table 12a, 12b, 52a, 52b Start position address 14a, 14b Character string length 16a, 16b, 56a, 56b Hash value

Claims (2)

[Claims] When storing a character string group including a plurality of character strings and one character string is a partial character string of another character string, the plurality of character strings are concatenated. Creating one concatenated character string, storing the start address of the partial character string in the concatenated character string, and the character string length of the partial character string in the concatenated character string, A method for reducing the size of a character string storage area, which does not require an area for storing each character constituting the character string. 2. The method according to claim 1, wherein the character string group is a constant pool in a Java language class file.