JP2003076606A - Program compression method - Google Patents

Abstract

PROBLEM TO BE SOLVED: To avoid the compression of one sub-routine, if having a smaller size than one page size, extending over two pages, thereby making the expansion of the page possible to be minimum, when expanded, and the processing time can be shortened. SOLUTION: The sub-routines of the execution files are compressed in pages for a program constituted by one or more execution files. Specifically, in allocating the pages, the sub-routines are lined in the order of a big size (Step T1), the empty space of the first page is always checked at first (Step T5), and if the page is fully empty, the sub-routine is allocated in the page (YES in Step T6). When the sub-routine has a larger size than the page size it is allocated in the next page (Step T12-14). When the sub-routine has a smaller size than the empty space of the page it is allocated in the page (YES in Step T7).

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a method of compressing a program which is effective especially when the capacity of a memory for storing data is small.

[0002]

2. Description of the Related Art Java (R) (registered trademark of Sun Microsystems, Inc. in the United States, where R is a registered trademark)
Programs written in a language are compiled and distributed prior to execution into platform-independent code called bytecode. The Java (R) virtual machine executes a program by interpreting and executing bytecodes one instruction at a time using an interpreter. Recently, a Java (R) virtual machine that converts a bytecode into a native code by using JIT (Just-in-time Compiler) instead of directly executing the bytecode so that the program can be executed at high speed. There is also.

All execution files (class files) of Java (R) programs are compressed by a compression / archiver format called jar (java archive). Such a program written in the Java (R) language is used for a mobile phone, a PDA (Personal Digital Assistant).
s) or embedded appliances such as information appliances.

[0004]

However, the capacity of the ROM (Read Only Memory) or the RAM (Random Access Memory) that can be used in the embedded device is smaller than that of an ordinary computer. Therefore, there is a problem that a program with a large number of steps cannot be executed. Also ja
When running a program compressed by r, the entire class file needs to be decompressed, which requires more RAM.

The present invention has been made to solve the above problems, and an object of the present invention is to provide a method for compressing a program that requires a small memory capacity and reduces the execution processing time of the program. is there.

[0006]

Hereinafter, as the reference numerals appearing in this section, the reference numerals described in the embodiments of the invention are used as they are. A method of compressing a program according to the present invention assigns a subroutine included in a subroutine portion of the execution file for each page to a program written in a predetermined language and composed of one or a plurality of execution files, This is a method of compressing the created subroutine page by page (claim 1).

The subroutine section is a function composed of the instruction code of the execution file. The subroutine of the execution file is divided into one or a plurality of subroutine pages. Each subroutine page is a set of a plurality of subroutines of the execution file. The memory capacity can be reduced by compressing the subroutine part of the execution file by a specific compression method. Preferably, the predetermined language is an object oriented language.

Further, the execution file is divided into a subroutine section and a data section, and not only the page allocation and compression of the subroutine but also the data contained in the data section of the execution file is allocated for each page. May be compressed in page units (claim 2). The data part is all character strings and numerical values of the execution file. As a result, the memory capacity can be further reduced.

Further, the execution file is divided into a subroutine part, a data part, and a basic information part, and the basic information contained in the basic information part of the execution file is allocated for each page. You may compress with. The basic information section includes information other than the subroutine section and the data section of the execution file, that is, the number of subroutines, the length of all subroutines, the number of data, the data type of all data, the length of all character strings, and the like.
After decompression, the basic information is converted into a data structure for representing all of this information and stored in the program storage unit.

The page size of the allocated page may be variable for each page, and the upper limit may be set (claim 3). By setting the upper limit of page size and compressing pages in that unit, you can increase the execution speed in a limited memory area, reduce the decompression overhead,
When performing decompression, the cache memory hit rate can be improved as a whole. The page size may be the same for all pages (claim 4). If the page size is fixed, the page is compressed in that unit, and when decompression is executed, the cache memory is cached in that unit. The execution speed can be increased in a limited memory area, the decompression overhead can be reduced, and the cache hit rate can be improved as a whole. The distinction between variable and fixed page size is described later in association with page_size_type (S8).

The compression method used in the subroutine page and the data page may be changed (claim 5).
This improves the compression rate. The definition of the compression ratio used in this specification is (size before compression / size after compression). Various compression methods will be described later in association with comp_algorithm (S11). When pages are allocated to a program composed of a plurality of execution files, it is preferable to divide the pages so that a page including only subroutines of the same execution file is created according to the information contained in the execution files (claims). 6). As a result, the cache hit rate at the time of execution can be improved. In the "information included in the execution file", the size of the subroutine (S110) (S122), the size of the data (S30)
(S34) etc.

The process (A) according to claim 7, wherein when allocating pages, the subroutines are arranged in descending order of size, and for each of the arranged subroutines, from the first page every time.
(B) can be performed (when page_part (S7) is 1 in FIG. 9). The compression method of this program will be explained. When the page division is performed in the subroutine section, the subroutines are arranged in descending order and page allocation is performed. Allocation of each aligned subroutine always starts from the examination of the empty area of the first page, and if the entire page is free, the subroutine is allocated to the page. Subroutines that are larger than the page size and remain unallocated are allocated to the next page.

If the page is partially empty,
If the subroutine is smaller than the free space on the page, the subroutine is assigned to the page. If the subroutine is larger than the free space of the page, the subroutine is processed on the next page without being assigned to the page. By this processing, each subroutine can be assigned to each page. After assigning a subroutine, a free area is created for each page, but if another subroutine enters, it will be inserted, and if it does not enter, an empty area for each page will remain to the end.

With this algorithm, one subroutine will not be compressed across two pages as long as its size is smaller than the page size of one page. Therefore, at the time of decompression, the minimum page decompression is required and the processing time can be shortened. When allocating pages, the subroutines may be arranged in descending order of size, and the processing (C) according to claim 8 may be performed for each of the arranged subroutines (when page_part (S7) is 2 in FIG. 9). .

A method of compressing this program will be described.
When the page division is performed in the subroutine section, the subroutines are arranged in descending order to allocate pages. Each aligned subroutine will be packed in order from the youngest page. Therefore, the empty area remains on the last page, but there is no empty area on the first page or any pages in the middle. Therefore, this algorithm minimizes the number of pages for compressing the subroutine and saves memory space.

In the seventh and eighth aspects, when allocating pages, the subroutines may be arranged in descending order of execution frequency instead of in descending order of size (claims 9 and 10). In this way, the subroutine is analyzed, and the pages are compressed by dividing the pages so as to create the pages in the order of the most frequently executed subroutines, so that the hit rate at the time of execution is improved.

After page allocation, each instruction in the subroutine may be replaced by macro conversion and then compressed (claim 11). After page division in the subroutine section, a specific continuous instruction pattern of the subroutine is replaced with a macro instruction, compression is performed, and the compression rate increases,
The memory capacity can be reduced (reference numeral 1 in FIG. 22)
00). The compression algorithm may be changed for each page (claim 12). If the compression algorithm can be changed for each page, the compression rate is increased and the memory capacity can be reduced.

It is desirable to compress only pages having a page compression rate (size before compression / size after compression) of a certain value or more, and not perform page compression for pages that do not.
3). "Constant" means, for example, 100%. When the executable file to be compressed is a Java (R) class file, the Java class file is added to i) the method part corresponding to the subroutine, ii) the data part of utf8 that is a character string, and iii) the basic information part other than these Divide (Claim 1)
4, 15).

By using a compression method suitable for each of i), ii), and iii), the required memory capacity can be reduced. Furthermore, i) and ii) are divided into pages, and the pages can be compressed by a suitable compression method to reduce the required memory capacity.
Moreover, the cache hit rate can be improved.

[0020]

BEST MODE FOR CARRYING OUT THE INVENTION Embodiments of the present invention will be described in detail below with reference to the accompanying drawings. <Table of contents> 1. Structure of program compression format header 2. Structure of basic information section of program compression format 3.1 utf8 (data) of program compression format, page size of method (subroutine) Shape of compression format 3.2 utf8 (data) of program compression format, size of method (subroutine) Compressed shape 4. Format of utf8 part of program compression format 5. Method format of program compression format 6.1 Program execution device form (only method compression) 6.2 Program execution device form (all compression) <text> 1. Structure of Header in Program Compression Format FIG. 2 is a top layer structure diagram of the program compression format assuming Java (R).

FIG. 3 is a detailed diagram showing the structures S3 to S14 of the header layer 2 in the program compression format of FIG. Less than,
The structures S3 to S14 of the header layer 2 will be described in order. 1.1 magic_number (S3) is 16 bit, hexadecimal 0x7cd
f is for identifying the program compression format file of the present invention from other files. 1.2 version (S4) is a 16-bit version number of the program compression format of the present invention.

1.3 java_version (S5) is the 16-bit minor_versio of the compressed original java class file.
n and 16-bit major_version are shown. 1.4 data_comp (S6) is 1 bit, and if 0,
Only the method part corresponding to the subroutine is compressed.
In the case of 1, the method part, of the character string corresponding to the data
The utf8 part and the basic information part other than the method part and the utf8 part are compressed.

1.5 page_part (S7) is 2 bits, and if 0, it is a method (subroutine) or utf8.
(Data) is directly compressed without being divided into pages. If 1, method (subroutine) or utf8
(Data) is divided into pages and compressed. FIG. 5 is a diagram for explaining a method of dividing a method (subroutine). When page_part (S7) is 1, the division method shown in FIG. 5 is used. First, as shown in the left column, method
The methods (subroutines) 0 to 5 of s [] (S102) are arranged in order. These methods (subroutines) 0-5
Are sorted according to the sort_type (S9) algorithm as shown in the middle row. The method (subroutine) is
Pages are assigned in the order of arrangement as shown in the right column. If a page (n) is already assigned a method (subroutine) and the next method (subroutine) does not fit in the rest of the page, this method (subroutine) is assigned to the next page.

In the example of FIG. 5, the method (subroutine) 4 is assigned first. Since the size of this method (subroutine) 4 is larger than the page, it is divided into a plurality of pages (pages 0 and 1). Page 0 here
The empty area of is 1 and the empty area of page 1 is 4096 + 40
It becomes 96-5817 = 2375 (byte). The next method (subroutine) 1 is assigned to page 2 because it does not enter page 0 and page 1. Free space on page 2 is 4096-2
702 = 1394 (byte). The next method (subroutine) 3 does not enter page 0, but page 1 can be entered, so it is assigned to page 1. With this, the free area of page 1 becomes 2375-1806 = 569 (byte). Since the next method (subroutine) 0 does not enter pages 0 and 1, it is allocated to page 2 (free area 1394).
Now the free area of page 2 is 1394-1365 = 29 (bytes). The final methods (subroutines) 2 and 5 are assigned to page 3 because they can only enter page 3. In this way, the method (subroutine) is allocated to the youngest page as much as possible in order to improve the cache hit rate.

The same applies when the method (subroutine) is replaced with utf8 (data). FIG. 7 is an explanatory diagram for explaining an example in which the method (subroutine) is replaced with utf8 (data). FIG. 6 is a diagram for explaining another method of dividing a method (subroutine). pa
When ge_part (S7) is 2, the dividing method of FIG. 6 is used. First, as shown in the left column, methods (subroutines) 0 to 5 of methods [] (S102) are arranged in order. These methods (subroutines) 0-5 use sort_type (S
According to the algorithm of 9), they are arranged as shown in the middle row. The methods (subroutines) are assigned to pages in the order of arrangement as shown in the right column. Methods (subroutines) are assigned to pages so that there is no space on pages other than the last page. Thereby, the compression rate can be increased.

The same applies when the method (subroutine) is replaced with utf8 (data). FIG. 8 is an explanatory diagram for explaining an example in which the method (subroutine) is replaced with utf8 (data). As described above, when pages are allocated, it is possible to create a page consisting only of subroutines of the same execution file according to the information contained in the execution file (claim 6).

1.6 page_size_type (S8) is page_p
It exists only when art (S7) is not 0. page_size_typ
e (S8) is 1 bit, and if page_size_type (S8) is 0 (corresponding to claim 3), the upper limit of the variable page size is set, and page compression / expansion is executed in that unit. page
When _size_type (S8) is 1 (corresponding to claim 4), the page size is fixed and page compression / expansion is performed in that unit. 1.7 sort_type (S9) exists only when page_part (S7) is not 0.

Sort_type (S9) is 1 bit and sort_t
When ype (S9) is 0 (corresponding to claim 8), according to the present invention, a method (subroutine) or utf8 (data) is assigned to a page using an algorithm for reducing the number of pages. An algorithm for assigning a method (subroutine) is shown in FIGS. 9 and 10. This algorithm corresponds to the case where page_part (S7) is 1 (FIG. 5) and 2 (FIG. 6). This algorithm is targeted for the method (subroutine), but the same algorithm is applied when targeting utf8 (data) (FIGS. 7 and 8).

Referring to FIG. 9, from the start, the subroutines are first arranged in descending order (step T1). page_pa
When rt (S7) is 2 (see FIG. 6), the subroutine is page-divided so that there is no empty area other than the last page in the alignment order. When page_part (S7) is 1 (see FIG. 5), it is necessary to check the free area of the page when assigning each subroutine to the page.

After the alignment, the size of one page, pagesize, is set (step T2). This pagesize is a constant and fixed value. Next, the subroutine variable s = 0 and the page variable p = 0 are set (step T3). Next, the page_pa
rt (S7) is compared with 1 (step T4), and if it is 1,
Since it is necessary to check all pages, p = 0 is set (step T5). If the page_part (S7) is 2,
Subroutines are assigned to pages sequentially, so
Do not set p = 0 every time (skip step T5).

If page_part (S7) is 1, and the size of the subroutine is larger than the page size, it is necessary to divide the subroutine into a plurality of empty pages. Therefore, in step T6, the p-th page, page [p] Free space is pagesize
Check if it is. If the empty area of page [p] is less than pagesize in step T6, it is confirmed in step T7 whether the empty area of page [p] is larger than the subroutine [s]. If the empty area of the page [p] is less than the size of the subroutine [s], p is set to p + 1 (step T8) to search for the next page, and the process returns to the entrance of step T6.

If the empty area of the page [p] is larger than the size of the subroutine [s] in step T7, the process proceeds to step T10. In step T6, the empty area of page [p] is pagesize
If it is (if one page is completely empty), the process proceeds to step T10. In step T9, it is confirmed whether page_part (S7) is 1 or 2, and if it is neither 1 nor 2, page division is not performed, and the process ends.

If page_part (S7) is 2 in step T9, the process proceeds to step T10. In step T10, the size of the subroutine [s] is set to ss, and step T11 in FIG.
Proceed to. In step T11 and thereafter, allocation is started.
When it is determined in step T11 that ss is larger than the empty area of page [p] (no in step T11), the subroutine
Since [s] does not fit on page [p], it allocates as much as it can on page [p] and allocates the rest to the next page.
That is, ss = ss-vacant area of page [p] (step T1
2), empty area of page [p] = 0 (step T13), p = p +
The value is set to 1 (step T14), and the input is returned to step T12.

At step T11, if ss is less than or equal to the free space of page [p] (yes at step T11), the entire ss can be allocated to page [p], so ss is allocated from the free space of page [p]. Is subtracted (step T15). Here, the page allocation of the sub-routine [s] is completed, s = s + 1 is set (step T16), and step T15 is entered. In step T17, if s is equal to the predetermined number of subroutines, the process is terminated, and if not, the process returns to the input of step T4 to start the process of the next subroutine. The above is the description of FIGS. 9 and 10.

When sort_type (S9) is 1 (corresponding to claim 9), the method (subroutine) is analyzed, and pages are divided and compressed so as to create pages in the order of subroutines with high execution frequency. 1.8 page_comp (S10) exists only when page_part (S7) is not 0. page_comp (S10) is 1 bit, and if page_comp (S10) is 0, comp_algorithm (S1
Select the algorithm for page compression according to 1). In case of 1, the method (subroutine) page is compressed by method_algorithm (S267), and utf8_algorith
Compress utf8 (data) pages by m (S264).

1.9 comp_algorithm (S11) is page_pa
It exists only when rt (S7) is 0, or when page_part (S7) is not 0 and page_comp (S10) is 0. comp_alg
orithm (S11) is a compression format used for utf8 (data) or method (subroutine), and 3 bits are used as follows. utf8 (data) compression is data_comp (S6)
Only when is 1. When comp_algorithm (S11) is 0, utf8 (data) is the compression method 1 of the page of the utf8 part, and the method (subroutine) is the compression method 1 of the page of the method part.

When comp_algorithm (S11) is 1, utf8
(Data) is the page compression method 2 of the utf8 section, and the method (subroutine) is the page compression method 2 of the method section. If comp_algorithm (S11) is 2, utf8
(Data) is the page compression method 1 of the utf8 section, and the method (subroutine) is the page compression method 3 of the method section.

If comp_algorithm (S11) is 3, utf8
(Data) is the page compression method 2 of the utf8 section, and method (subroutine) is the page compression method 4 of the method section. If comp_algorithm (S11) is 4, utf8
(Data) is the page compression method 1 of the utf8 section, and method (subroutine) is the page compression method 5 of the method section.

If comp_algorithm (S11) is 5, utf8
(Data) is the page compression method 2 of the utf8 section, and method (subroutine) is the page compression method 6 of the method section. If comp_algorithm (S11) is 6, utf8
(Data) is the page compression method 1 of the utf8 section, and the method (subroutine) is the page compression method 7 of the method section.

If comp_algorithm (S11) is 7, utf8
(Data) is the page compression method 2 of the utf8 section, and method (subroutine) is the page compression method 7 of the method section. Here, the definitions of page compression methods 1 and 2 of the utf8 (data) part will be described. utf8 (data) section page compression method 1: Fast dictionary-based lz-77 algorithm. API library information, attribute name information, and basic method (subroutine) descriptor information are used as the initial dictionary.

Method of compressing page of utf8 (data) part 2:
It is a combination of the high compression ratio lz-77 and adaptive Huffman. API library information, attribute name information, and basic method (subroutine) descriptor information are used as the initial dictionary. Next, the definition of page compression methods 1 to 7 in the method section will be described. Method page compression method 1: Division method 1 (S270)
Uses a fast dictionary-based lz-77 algorithm.

Method page compression method 2: A combination of the above-mentioned lz-77 and adaptive Huffman having a high compression rate is used for the division method 1 (S270). Method section page compression method 3: Division method 2 (S272)
Uses a fast dictionary-based lz-77 algorithm. Method section page compression method 4: Division method 2 (S272)
A combination of the above-mentioned lz-77 and adaptive Huffman having a high compression rate is used.

Method part page compression method 5: The opcode and the macro part of the division method 3 (S274) are compressed by the high-speed dictionary-based lz-77 algorithm, and the operand part is a compression method specialized for the operand part. To use. Method section page compression method 6: Division method 3 (S274)
The operation code and the macro part are compressed by the combination of lz-77 and adaptive Huffman having a high compression ratio, and the operand part uses a compression method specialized for the operand part.

Method section page compression method 7: The operation code of the division method 3 (S274) and the macro section are compressed from the fixed Huffman table specialized for the appearance frequency of macros, and the operand section is specialized for the operand section. The compression method is used. This method can be easily implemented as hardware. 1.10 count_size (S12) exists only when data_comp (S6) is 1. count_size (S12) is 1 bit, and if 0, the number of constant storage parts (constant pool) of the Java class file (c
onstant_pool_count (S30)), number of interfaces (inter
faces_count (S60)), number of fields (fields_count (S6
4)), the number of methods (subroutines) (methods_count (S10
0)), the number of attributes (attributes_count (S74) (S110) (S13
6)), the number of stacks of the method (subroutine) (max
_Stack (S118)), the number of local variables of the method (subroutine) (max_locals (S120)), the number of exception tables of the method (subroutine) (exception_table_length (12
4)), the number of exception attributes (number_of_exceptions (S14
4)), the number of classes in the built-in class attribute (number_of_classes
(S210)), line number table number of line number table attribute
(line_number_table_length (S164)), local variable table number of local variable table attribute (local_variable_table_l
ength (S176)) is 1 byte, and if 1 is 2 bytes, compression is performed.

FIG. 4 is a diagram for explaining an example of compressing only the required least significant bits. Figure 4 shows constant_
pool_count (S30), interfaces_count (S60), fields_
The length of uncompressed data (S15) such as count (S64) is n bits, the part to be encoded (required least significant bit (S17)) is m bits, and the part that does not need to be encoded (S16) Indicates that the length of is n−m bits. Only the m-bit portion constitutes the compressed data (S19). The mn bit portion is not included in the compressed data (S19). The same applies when the unit bits of length are replaced with bytes.

For example, n is 2 bytes. count_siz
If e (S12) is 0, the minimum required lower byte count (S17) m is 1
If the count_size (S12) is 1, then m = 2 bytes. 1.11 utf8_len_size (S13) has 1 data_comp (S6)
Exists only when. utf8_len_size (S13) is 4 bits and represents a length of 1 to 16 bits of the compressed utf8 (data) length (length (S52)) of the Java class file.

Referring to FIG. 4, length (S52)
Represents the original data (S15) of m = 16 bits, and m = [utf8_len
Data + 1 represented by _size (S13) +1] is the minimum required lower-order bit number (S
Represents 17). Here, only the lower m bits are directly encoded (S
18) and the compressed data (S19) is the lower m bits of data. Since the high-order nm bit is 0, it is not necessary to encode it. 1.12 attribute_len_size (S14) is data_comp (S
Only present if 6) is 1.

Attribute_len_size (S14) is 2 bits and represents the length of 1 to 4 bytes of various compressed attribute lengths of the Java class file. In the example of FIG. 4, various attribute lengths represent original data (S15) with m = 4 bytes, and m = [attribute
The data +1] represented by _len_size (S14) is the minimum required lower byte number (S17). Here, only the lower m bytes are directly encoded (S18), and the compressed data (S19) is the lower m bytes of data. The upper nm byte is 0, so it does not need to be encoded.

2. The structure of the basic information part 4 of the program compression format (see FIG. 2) exists only when data_comp (S6) is 1. When data_comp (S6) is 0, this shape is uncompressed and stored in the compression execution file storage unit (S1). Figure 1
FIG. 1 is a diagram showing a detailed structure of the basic information part layer 4 in the program compression format of FIG.

2.1 FIGS. 12 and 13 show the structure of the constant pool compression format 40 of FIG. Referring to FIG. 12, constant_pool_count (S30) is the count_siz
According to e (S12), compression is performed with 1 byte or 2 bytes. The constant_pool_count (S30) is followed by constant
_Pool_count-1 constant_pool [] (S32) information follows.

The type of the constant_pool [] is CONSTAN
T_Class, CONSTANT_Fieldref, CONSTANT_Methodref,
CONSTANT_InterfaceMethodref, CONSTANT_String, C
ONSTANT_Integer, CONSTANT_Float, CONSTANT_Long,
CONSTANT_Double, CONSTANT_NameAndType, CONSTANT
There is _Utf8, and each is distinguished by a tag (S34). The tag is compressed by a fixed Huffman table specialized for the tag. The Huffman fixed table is a table in which shorter codes are assigned to tags that are frequently used, and longer codes are assigned as the usage frequency decreases.

In the case of CONSTANT_Class, the constan
As shown in FIG. 13, t_pool [] is the tag and name.
It consists of _index (S36). In the case of the CONSTANT_Fieldref, the constant_pool [] is the tag, class_inde
It consists of x (S38) and name_and_type_index (S40).
In the case of CONSTANT_Methodref, the constant_pool
[] Indicates the tag, class_index (S38), and name_and
It consists of _type_index (S40).

In the case of CONSTANT_InterfaceMethodref, the constant_pool [] is the tag, class_inde
It consists of x (S38) and name_and_type_index (S40).
In the case of CONSTANT_String, the constant_pool []
Consists of the tag and string_index (S42). CO
In the case of NSTANT_Integer, the constant_pool [] includes the tag and 4 bytes (S44) of data.

In the case of the CONSTANT_Float, the constan
t_pool [] consists of the tag and 4-byte data (S44). In the case of CONSTANT_Long, the constant_pool
[] Is composed of the tag and 8 bytes (S46) of data.
In the case of CONSTANT_Double, the constant_pool []
Consists of the tag and 8 bytes (S46) of data.

In the case of CONSTANT_NameAndType, the above c
The onstant_pool [] includes the tag, name_index (S48), and descriptor_index (S50). CONSTANT_Ut
In the case of f8, the constant_pool [] is the tag, utf8
Length (S52) of the character string of, and bytes [length] of length length
It consists of the character string. The name_index (S36) (S48), class
_Index (S38), name_and_type_index (S40), string
_Index (S42) and descriptor_index (S50) are indexes of the constant pool constant_pool [] (S32), and are smaller than the constant_pool_count (S30). Therefore, compression is performed with the minimum number of bits representing the constant_pool_count (S30).

For example, constant_pool_count (S30) is 20
In case of, it can be expressed by at least 5 bits, and compression is performed by 5 bits. The CONSTANT_Integer and the CONSTANT
The next 4 bytes (S44) of the _Float tag are stored in the compression execution file storage unit 22 as they are in an uncompressed format.
The next 8 bytes (S46) of the CONSTANT_Long and CONSTANT_Double tags are directly stored in the compression execution file storage unit 22 in an uncompressed format.

The length (S52) of CONSTANT_Utf8 is compressed by the number of bits represented by utf8_len_size (S13). The CONSTANT_Utf8 is composed of the length (S52) and length (S52) bytes (bytes []) representing a character string, and the length (S52) is included in the constant pool compression format, and the bytes [] are included. Is the information of the utf8 part. All the bytes [] of CONSTANT_Utf8 are
length (S52), page_size (S235) and (i) Algorithm for reducing the number of pages (FIGS. 9 and 10), or
(ii) Assigned to the page of the utf8 section by an algorithm (not shown) that reduces the page expansion frequency,
It is compressed to mpressed_utf8_page [] (S263).

2.2 access_flags (S27) performs compression using a fixed Huffman table specialized for class file access flags. The Huffman fixed table is a table in which shorter codes are assigned to high-use access flags and longer codes are assigned as the use frequency decreases. 2.3 this_class (S28) is the constant pool
index of constant_pool [] (S32),
It is a value smaller than nstant_pool_count (S30). Therefore, lower level of this_class (S28) | log ₂ constant_pool_c
ount (S30) | encodes only bits and compresses (|
| Represents rounding up to an integer. same as below). For example, if constant_pool_count is 20 as in FIG. 4, it can be represented by at least 5 bits, and only the lower 5 bits are encoded,
Perform compression.

2.4 super_class (S29) is an index of the constant pool constant_pool [] (S32), and is a value smaller than the constant_pool_count (S30). Therefore, lower than super_class (S28) | log ₂ cons
tant_pool_count (S30) | Only bits are encoded and compressed. For example, similar to Figure 4, constant_pool_count
If is 20, it can be represented by at least 5 bits, and only the lower 5 bits are encoded and compressed.

2.5 FIG. 14 shows the detailed structure of the interface compression format 42 for FIG. Referring to FIG. 14, interfaces_count (S60) is the above count_size (S12).
According to this, compression is performed with 1 byte or 2 bytes. The above
Next to interfaces_count (S60), all interfaces_co
The unt interfaces [] (S62) are indexes of the constant pool constant_pool [] (S32), and
It is a value smaller than constant_pool_count (S30). Therefore, lower level of interfaces [] (S62) | log ₂ constant_pool
_Count (S30) | Only bits are encoded and compressed. For example, when constant_pool_count is 20 as in FIG. 4, it can be represented by at least 5 bits, and only the lower 5 bits are encoded and compressed.

2.6 FIG. 15 and FIG. 16 show details of the field compression format 44 for FIG. In FIG. 15, fields_count (S64) is compressed by 1 byte or 2 bytes according to the count_size (S12) (0 or 1). Next to the fields_count (S64), fields_count
Fields [] (S66) information follows.

Fields [] are access_flags (S68), name
_Index (S70), descriptor_index (S72), attributes_
count (S74), and attributes_count attributes []
(S76). Field attributes [] (S76)
ConstantValue, Synthetic, and Deprec as attributes of
ated is defined. Referring to FIG. 16, ConstantVal
ue is attribute_name_index (S78), attribute_leng
It consists of th (S79) and constant_value_index (S80).

Synthetic and Deprecated are attribute_
It consists of name_index (S81) and attribute_length (S82). For other attributes than ConstantValue, Synthetic, and Deprecated, attribute_name_index (S83), attribu
te_length (S84) and attribute_length bytes (S
85). The attribute_name_index (S78) (S81)
(S83) is the constant pool constant_pool [] (S
32) index, the Constant Value, and the S
An attribute name of ynthetic, the Deprecated, or the other attribute is specified, and the fixed Huffman table specialized in the attribute name of FIG. 17 is used for compression. The attribute_name_index (S
If (78) is the Constant Value, (S78) is a Constant
The Huffman code (S88) of tValue is stored. Said attri
If bute_name_index (S81) is the Synthetic,
A Huffman code of Synthetic (S92) is stored in (S81). The attribute_name_index (S81) is the Deprecate
If it is d, (S81) contains the Deprecated Huffman code (S
95) is stored. When the attribute_name_index (S83) is the other attribute (S96), an escape code (S97) is output in the fixed Huffman table, and then the attribute_na
The compression information (S98) of me_index is output. In this case, lower than attribute_name_index | log ₂ constant_poo
l_count (S30) | Only bits are encoded and compressed.
For example, referring to FIG. 4, when constant_pool_count is 20, it can be represented by at least 5 bits, and only the lower 5 bits are encoded and compressed.

The access_flags (S68) performs compression using a fixed Huffman table specialized for field access flags. The name_index (S70), the constant_value_ind
ex (S80) and the descriptor_index (S72) are indexes of the constant pool constant_pool [] (S32), and are smaller than the constant_pool_count (S30). Therefore, the lower part of name_index (S70) | log ₂ con
stant_pool_count (S30) | Only bits are encoded and compressed. For example, similar to Fig. 4, constant_pool_coun
When t is 20, it can be represented by at least 5 bits, and only the lower 5 bits are encoded and compressed.

The attributes_count (S74) is the coun
According to t_size (S12), compression is performed with 1 byte or 2 bytes. The attribute_length (S79) (S82) (S84) is compressed by 1, 2, 3, 4 bytes according to the attribute_len_size (S14). Other attribute's attribute_length
The number of bytes (S85) is stored in the compression execution file storage unit without being compressed.

2.7 FIG. 18 is a diagram showing details of the method (subroutine) compression format 46 for FIG.
The methods_count (S100) performs compression with 1 byte or 2 bytes according to the count_size (S12). The meth
ods_count (S100) is followed by methods_count methods
[] (S102) Information follows.

Methods [] is access_flags (S104), nam
e_index (S106), descriptor_index (S108), attribute
s_count (S110), and attributes_count attributes
It consists of s [] (S112). The access_flags (S104) performs compression using a fixed Huffman table specialized for method (subroutine) access flags. The Huffman fixed table is a table in which short codes are assigned to frequently used access flags, and longer codes are assigned as the usage frequency becomes smaller.

As attributes of the attributes [] of the field, Code, Exceptions, Synthetic, and Deprecated
Is defined. In the case of the code, as shown in FIG. 19, the compression format of attributes is attribute_name_index (S
114), attribute_length (S116), max_stack (S118), m
ax_locals (S120), code_length (S122), code_length
Byte length code [], exception_table_length (S12
4), exception_table_length exception_table
[] (S126), attributes_count (S136), and attributes
It consists of _count attributes [] (S138).

The code [] is the actual command and the information of the method section 8. The code [] is the code_le
ngth (S122), page_size (S235) and (i) Algorithm for reducing the number of pages (FIGS. 9 and 10) or (ii)
It is assigned to the page of the method section by an algorithm (not shown) that reduces the expansion frequency of the page,
compressed_method_page [] (S266). The exception_table [] (126) is start_pc (S128), end_
It consists of pc (S130), handler_pc (S132), and catch_type (S134).

As an attribute of attributes [] of the code,
LineNumberTable and LocalVariableTable shown in FIG.
Is defined. In the case of the LineNumberTable, attribu
tes compression format is attribute_name_index (S160), attri
bute_length (S162), line_number_table_length (S1
64), and line_number_table_length line_numb
er_table [] (S166). The line_number_table
[] (S166) is start_pc (S168) and line_number (S17)
It consists of 0).

In the case of the above LocalVariableTable, attrib
utes compression format is attribute_name_index (S172), attr
ibute_length (S174), local_variable_table_lengt
h (S176) and local_variable_table_length locs
al_variable_table [] (S178). The local_var
iable_table [] (S178) is start_pc (S180), length
(S182), name_index (S184), descriptor_index (S18
6) and index (S188).

In the case of the Exceptions, as shown in FIG. 20, the attributes compression format is attribute_name_index.
(S140), attribute_length (S142), number_of_excep
tions (S144) and number_of_exceptions exceptions
on_index_table [] (S146). The Synthetic or
For Deprecated, the attributes compression format is attribut
It consists of e_name_index (S148) and attribute_length (S150).

Code, Exceptions, LineNumb
For other attributes than erTable, LocalVariablTable, Synthetic, and Deprecated, attributes
The compression format is attribute_name_index (S152), attribute
e_length (S154), and attribute_length bytes (S
156). The attribute_name_index (S114) (S14
0) (S148) (S152) (S160) (S172) (S190) is an index of the constant pool constant_pool [] (S32), and the Code, the Exceptions, and the LineNumberTabl
e, the LocalVariablTable, the Synthetic, the Depre
Specify the attribute name of cated, or the other attributes, and click
It is compressed by a fixed Huffman table specialized for 7 attribute names. When the attribute_name_index is the Code, the Huffman code (S89) of the Code is stored in the attribute_name_index (S114). The attribute_name_in
If dex (S140) is the Exceptions, attribute_na
Exceptions Huffman code (S9
0) is stored. If the attribute_name_index (S160) is the LineNumberTable, attribute_name_in
Huffman code (S93) of LineNumberTable in dex (S160)
Is stored. If the attribute_name_index (S172) is the LocalVariableTable, attribute_name_i
Huffman code of LocalVariableTable in ndex (S172)
(S94) is stored. The attribute_name_index (S14
8) is the Synthetic, attribute_name_inde
The Synthetic Huffman code (S92) is stored in x (S148). The attribute_name_index (S148) is the Deprec
If it is ated, the attribute_name_index (S148) is D
The eprecated Huffman code (S95) is stored. Said at
If tribute_name_index is the other attribute (S96),
In the fixed Huffman table, the escape code (S97) is output, and then the compression information (S98) of the attribute_name_index is output. In this case, only the lower | log ₂ constant_pool_count (S30) | bits of the attribute_name_index are encoded and compressed. For example, as in Figure 4, consta
When nt_pool_count is 20, it can be represented by at least 5 bits, and only the lower 5 bits are encoded and compressed.

The name_index (S106) (S184), the descr
iptor_index (S108) (S186), the catch_type (S134),
And all the exception_index_table [] (S146)
It is an index of the constant pool constant_pool [] (S32) and is smaller than the constant_pool_count (S30). Therefore, the name_index (S106) (S18
4), the descriptor_index (S108) (S186), the catch_
type (S134), and all the exception_index_tabl
Lower level of e [] (S146) | log ₂ constant_pool_count (S30) |
Only bits are encoded and compressed. For example, when constant_pool_count is 20 as in FIG. 4, it can be represented by at least 5 bits, and only the lower 5 bits are encoded and compressed.

The attributes_count (S110) (S136), the max_stack (S118), the max_locals (S120), the cod
e_length (S122), the exception_table_length (S12
4), the line_number_table_length (S164), and the local_variable_table_length (S176) are the coun
According to t_size (S12), compression is performed with 1 byte or 2 bytes. The attribute_length (S116) (S142) (S150) (S1
54) (S162) (S174) (S192) is the attribute_len_size
According to (S14), it is compressed with any of 1, 2, 3, or 4 bytes.

The attribute_length of the other attribute
The bytes (S156) (S194) are stored in the compression execution file storage unit without being compressed. The code_length (S122) is compressed by the minimum number of bits representing the attribute_length (S116). Start_pc (S128) (S168), length
(S182), the end_pc (S130) (S182), and the handler
_Pc (S132) encodes only the lower | log ₂ code_length (S122) | bits and performs compression. For example, as in Figure 4,
When code_length is 20, it can be represented by at least 5 bits, and only the lower 5 bits are encoded and compressed.

The 16 bits of the line_number (S170) are stored in the compression execution file storage unit in an uncompressed format.
The index (S188) is compressed by the lowest bit representing the max_locals (S120). For example, when max_locals is 20, it can be represented by at least 5 bits, and compression is performed by 5 bits. 2.8 FIG. 22 is a detailed diagram of the attribute compression format 48 for FIG.

Attributes include SourceFile, InnerClasses, and Deprecated. In the case of the SourceFile, the compression format 48 of the attribute is attribute_name_index (S200), at
tribute_length (S202) and sourcefile_index (S204)
Consists of. In the case of Inner Classes, the compression format 48 of the attribute is attribute_name_index (S206), attribute
e_length (S208), number_of_classes (S210), and nu
It consists of mber_of_classes classes [] (S212).

The classes [] are inner_class_info_
index (S214), outer_class_info_index (S216), inne
r_class_name_index (S218), inner_class_access
_Flag (S220). In the case of Deprecated, the compression format 48 of the attribute is attribute_name_index (S222)
And attribute_length (S224). Source Fil
For other attributes than e, the InnerClasses, and the Deprecated, the compression format 48 of the attribute is attribute
_Name_index (S226), attribute_length (S228), and
It consists of attribute_length bytes (S230).

The attribute_name_index (S200) (S206)
(S222) and (S226) are the constant pool constant_pool
It is an index of [] (S32), the attribute name of the SourceFile, the InnerClasses, the Deprecated, or the other attribute is designated, and is compressed by the fixed Huffman table specialized in the attribute name of FIG. The attribute_name_ind
When ex is the above SourceFile, attribute_name_ind
The Huffman code (S87) of SourceFile is stored in ex (S200). The attribute_name_index (S206) is the Inne
If rClasses, attribute_name_index (S206)
The Huffman code (S91) of Inner Classes is stored in. The attribute_name_index (S222) is the Deprecat
If it is ed, attribute_name_index (S222) has Dep
The Huffman code (S95) of recated is stored. The attr
When ibute_name_index is the other attribute (S96), the escape code (S97) is output in the fixed Huffman table, and then the compression information (S98) of the attribute_name_index is output. In this case, the compression of the attribute_name_index is performed by encoding only the lower | log ₂ constant_pool_count (S30) | bits. For example, cons
When tant_pool_count is 20, it can be represented by at least 5 bits, and only the lower 5 bits are encoded and compressed.

The attribute_length (S202) (S208) (S22
4) (S228) is based on the attribute_len_size (S14)
It is compressed with 1, 2, 3, or 4 bytes. Sourcefile_
index (S204), the inner_class_info_index (S214),
The outer_class_info_index (S216) and the inner
_Class_name_index (S218) is an index of the constant pool constant_pool [] (S32), and
It is a value smaller than constant_pool_count (S30). Therefore, only the lower | log ₂ constant_pool_count (S30) | bits are encoded and compressed. For example, co
When nstant_pool_count is 20, it can be represented by at least 5 bits, and only the lower 5 bits are encoded and compressed.

The number_of_classes (S210) is the c
According to ount_size (S12), compression is performed with 1 byte or 2 bytes. Inner_class_access_flag (S220)
Compresses using a fixed Huffman table specialized for class file access flags. The Huffman fixed table is a table in which short codes are assigned to frequently used access flags, and longer codes are assigned as the usage frequency becomes smaller.

3.1 Program compression format utf8 (data), method (subroutine) page size compression format shape This book "Program compression format utf8 (data), method (subroutine) page size compression format" is ,
It exists only when page_part (S7) is not 0. FIG. 23
[Fig. 3] is a diagram showing "page table" 5 of utf8 (data) and method (subroutine) shown in Fig. 2. The part for utf8 (data) exists only when data_comp (S6) is 1.

When page_size_type (S8) is 0 (claim 3), page_size (S235) is 16 bits and represents the page size from 0 to 65535 bytes as it is. page_size_
When type (S8) is 1 (claim 4), page_size (S235) is the page size of the utf8 (data) and the method, and is selected by 3 bits. Therefore, up to 8 page sizes can be selected in this compression format.
A page size of 6,512, 1024, 2048, 4096, 8192, 16384, 32768 bytes can be selected. page_size = 2 ^ (8+ [3
Bit compressed data]). Here, "^" represents exponentiation.

Number_of_utf8 (S236) is the constant
CONSTANT_Utf8 in _pool [] (S32), utf8_
seq [] (S237) represents the order of utf8 (data) in the constant_pool [] (S32) when dividing utf8 (data) into pages. The index of the constant_pool [] of the utf8_seq [] is compressed by | log ₂ number_of_utf8 | bits. method_seq [] (S239) is the method [] (S10) when dividing the method (subroutine) into pages.
Indicates the order of methods (subroutines) in 2). The me
The index of methods [] (S102) of thod_seq [] is compressed by | log ₂ methods_count (S102) | bits.

The utf8_seq [] (S237) and the method_s
If sort_type (S9) is 1 in eq [] (S239) (claim 9),
The order of utf8 (data) and method (subroutine) divided into pages depends on the execution result of the method (subroutine). If sort_type (S9) is 0 (Claim 8), the order of utf8 (data) and method (subroutine) divided into pages can be obtained only by the information in the basic information section, and thus the utf8_seq [] (S23
7) and the method_seq [] (S239) do not exist.

The length (S52) of each CONSTANT_Utf8 and each code_length (S122) are variable, and each page includes the maximum number of the utf8 (data) or the maximum number of the method (subroutine). CONSTANT_
Utf8 length or each code_length is page_
If it is larger than size, it is divided into multiple pages. When the page compression rate is prioritized, the page allocation algorithm (see FIGS. 9 and 10) that reduces the number of pages causes utf8
Assign (data) or method (subroutine) to the page.

When the decompression time of the compressed page is prioritized, utf8 (data) or method (subroutine) is allocated to the page by a page allocation algorithm (not shown) that reduces the frequency of page expansion. number_of
_Utf8_page (S242) is the number of pages of utf8 (data), length (S52) of CONSTANT_Utf8, page_siz
e, page_part (S7), sort_type (S9), and utf8_seq []
Ask.

Number_of_method_page (S246) is the number of pages of the method (subroutine), and the code_le
ngth, the page_size, page_part (S7), sort_type (S
9) and method_seq []. Each number_of
_Utf8_page compressed_utf8_page_size [] (S24
4) is a table of sizes of all compressed utf8 (data) pages. Compressed for each number_of_method_page
_Method_page_size [] (S248) is a table of page sizes of all compressed methods (subroutines).

All the compressed_utf8_page_size
[] And the compressed_method_page_size [] are lo
g ₂ Compress with pagesize bits. In the present invention, when the class file is executed, the method (subroutine) and utf8 that are executed without decompressing the entire class file
Only by expanding the page of (data), the memory capacity of the program storage unit is reduced. Therefore, when decompressing a page, (a) which compressed_utf8_pag is used for all the bytes [] that are character strings of CONSTANT_Utf8.
Compressed to e [] (S263), (b) All the above Codes of Code
It is necessary that the address where ode [] is compressed_method_page [] (S266) is compressed, and (c) the compressed page of the compression execution file storage unit is stored.

The confirmation of the page of the utf8 part to which bytes [] of the CONSTANT_Utf8 of (a) and the start address in the page are confirmed by the length (S52), page_size (S235)
And (i) an algorithm that reduces the number of pages (FIGS. 9 and 10) or (ii) an algorithm that reduces the page expansion frequency (not shown). To confirm the page of the method part to which the code [] of the Code of (b) is assigned and the start address in the page,
de_length (S122), page_size (S235) and (i) an algorithm that reduces the number of pages (FIGS. 9 and 10) or (ii) an algorithm that reduces the expansion frequency of the page
(Not shown).

The above (c) is the compressed_utf8_page
_Size [] and the compressed_method_page_size []
The address where the page is stored is confirmed by referring to the table. The confirmation is performed as described with reference to FIG. Figure 2
4, S249 is the compression execution file storage unit (S1), and number_of_utf8_page (S242) = 1 and number_of_
This is an example of method_page (S246) = 2. Information of the page size (S242) of the compressed utf8 section is stored in S250, and information of the page size (S246) of the two compressed method sections is stored in S251 and S252, respectively. Compressed utf8
The information of the section page (S263) starts from address n (S253).
The information of the pages (S266) of the two compressed methods (subroutines) stored in 254 is stored in S256 starting from the address m (S255) and S258 starting from the address o (S257), respectively. When the execution is performed, first the basic information section 4 is S2.
It is expanded in 59 program storage (S2). Basic information section 4
The information expanded next to is S235. When sort_type (S9) is 1, S237 and S239 are present, are expanded after S235, and are used in the sorting algorithm according to claim 7. Next, all S244 and S248 are expanded. After stretching S235,
The compressed size of all S244 (S250) and S248 (S251, S252) was confirmed, and number_of_utf8_page (S242) and number_
First compressed utf8 with of_method_page (S246)
The start address n (S253) of the (data) page (S254) can be obtained and stored in the utf8 (data) page table (S260) of the program storage unit (S259). After the expansion of the next S250
It is the size of S254, and the address n (S253) + [expansion result of S250] is
This is the start address m (S255) of S256. The result is stored in S261 of the method (subroutine) table. Similarly, the start address o (S257) of S258 is obtained and stored in S262. S254, S256, S
When it is necessary to extend 258, the start address of each is confirmed by S260, S261, and S262.

3.2 Program compression format utf8 (data), method (subroutine) size compression format shape This book "Program compression format utf8 (data), method (subroutine) size compression format shape" is page_
It exists only when part (S7) is 0. This "Program compression format utf8 (data), method (subroutine) size compression format shape" is 3.1 "Program compression format
utf8 (data), method (subroutine) page size compression format ", page_size (S235) does not exist, number_of_utf8_page (S242) and number_of_
method_page (S246) becomes 1.

Compressed_utf8_page_size [] (S244)
Compression of compressed_method_page_size []
In (S248), compression is performed so that the number of bits is log ₂ pagesize. In case of utf8 (data), pagesize is all CO
It is the sum of the length (S52) of NSTANT_Utf8. For method (subroutine), pagesize is all code_leng
This is the sum of th (S122). 4. Format of utf8 part of program compression format This "format of utf8 part of program compression format" is data_comp
It exists only when (S6) is 1.

FIG. 25 shows the details of the utf8 section 6 shown in FIG. number_of_utf8_page is the same as in FIG. compressed_utf8_page [] (S263) is the page of all the compressed utf8 parts, and utf8_algorithm (S26
4) and compressed_utf8_data (S265). compre
The ssed_utf8_data (S265) is the actually compressed data. utf8_algorithm (S264) is 2 bits, page_c
It exists only when omp (S10) is 1, and utf8_algorithm (S26
When 4) is 0, the compression method 1 of the page of the utf8 part is used, and when utf8_algorithm (S264) is 1, the compression method 2 of the page of the utf8 part is used and utf8_algorithm (S264) 2
In case of uncompressed utf8 (data) data is compressed_ut
It is stored in f8_data (S265). When page_comp (S10) is 0, compression is performed by comp_algorithm (S11).

Details of the compression method are as follows. The method of compressing pages of the utf8 part 1: A high-speed dictionary-based lz-77 algorithm. API library information, attribute name information, and basic method (subroutine) descriptor information are used as the initial dictionary. The compression method of the page of the utf8 part 2: The high compression ratio l
It is a combination of z-77 and adaptive Huffman. API library information, attribute name information, and basic method (subroutine) descriptor information are used as the initial dictionary.

When the compression ratio (size before compression / size after compression) is 105% or less, compressed_utf8_data (S265) becomes the original data which is not compressed (claim 13). 5. Format of Method Section 8 in Program Compression Format FIG. 26 is a diagram showing details of the method section 8 shown in FIG. number_of_method_page is the same as in FIG. compressed_method_page [] (S266) is a page of all the compressed method parts, and method_algori
It consists of thm (S267) and compressed_method_data (S268).

Compressed_method_data (S268) is the actually compressed data. method_algorithm (S267) is 4
It is a bit and exists only when page_comp (S10) is 1,
When method_algorithm (S267) is 0 to 6, compression method 1 to 7 of the page of the method part is used and method_algorithm (S26
When 7) is 7, uncompressed method (subroutine) data is stored in compressed_method_data (S268). pa
If ge_comp (S10) is 0, the compression is comp_algorithm (S1
Follow step 1).

Details of the compression method are as follows. The page of the method part can be divided as shown in FIG. Here, the Java instruction is a 1-byte opcode and a plurality of 1-byte operands (operan).
d). The division method 1 (S270) is a format in which the pages of the method section are not divided. Split method 2 (S
272) is a division method in which continuous opcodes of a specific pattern are replaced with macros. The operand of the macro instruction 34 is placed after the macro. 53 Java instructions
However, up to 256-203 = 53 macros for 1 byte can be defined. The compression rate can be increased by making the opcode macro.

The division method 3 (S274) is a method in which the opcode and macro portion are divided into pages and the operand portion is divided into pages. For the division method 1, the division method 2, and the division method 3, the following page compression methods 1 to 7 in the method section can be selected. Method page compression method 1: Division method 1 (S270)
Uses a fast dictionary-based lz-77 algorithm.

Method page compression method 2: A combination of the above-described lz-77 and adaptive Huffman having a high compression rate is used for the division method 1 (S270). Method section page compression method 3: Division method 2 (S272)
Uses a fast dictionary-based lz-77 algorithm. Method section page compression method 4: Division method 2 (S272)
A combination of the above-mentioned lz-77 and adaptive Huffman having a high compression rate is used.

Method section page compression method 5: The opcode of the division method 3 (S274) and the macro section are compressed by the high-speed dictionary-based lz-77 algorithm, and the operand section is specialized for the operand section. To use. Method section page compression method 6: Division method 3 (S274)
The operation code and the macro part are compressed by the combination of lz-77 and adaptive Huffman having a high compression ratio, and the operand part uses a compression method specialized for the operand part.

Method section page compression method 7: The opcode of the division method 3 (S274) and the macro section are compressed from the fixed Huffman table specialized for the appearance frequency of macros, and the operand section is specialized for the operand section. The compression method is used. This method can be easily implemented as hardware. The compression method specialized for the operand part is as follows. The types of operands include an operand that refers to a local variable, a relative address of a branch destination, and the constant pool constant_pool [].
Operand referencing the index of (S32), newarray
Atype operand of instruction, lookupswitch and tableswit
There is a ch instruction operand.

The operand referencing the local variable is compressed by the number of bits corresponding to the local variable of the method (subroutine). For example, when max_locals (S120) is 20, as in FIG. 4, it can be represented by at least 5 bits, and only the lower 5 bits are encoded and compressed. The operand of the branch destination relative address is the code_le
The compression is performed by the number of bits corresponding to ngth (S122). For example, when code_length (S122) is 20 as in FIG. 4, it can be represented by at least 5 bits, and only the lower 5 bits are encoded and compressed.

The atype operand of the newarray instruction is a
It compresses by the fixed Huffman table specialized for type. The Huffman fixed table is a table in which short codes are assigned to atypes that are frequently used and longer codes are assigned as atypes are used less frequently. Table switch and lookup switc
To compress the operand of the h instruction, first encode the minimum required number of bits in the operand other than the relative address of the branch destination, and the operand of the relative address of the branch destination is compressed by the number of bits corresponding to the code_length. Compresses the operands other than the branch destination relative address according to the minimum required number of bits. For example, max_locals (S12
When 0) is 20, it can be represented by at least 5 bits, and only the lower 5 bits are encoded and compressed.

When the compression ratio (size before compression / size after compression) is 105% or less, compressed_utf8_data (S265) becomes the original data that is not compressed (claim 13). 6.1 Form of Program Execution Device 1: Only Method (Subroutine) is Compressed A program execution device according to an aspect of the present invention executes a program described in a predetermined language. As shown in FIG. 1, this program execution device reads a compression execution file storage unit 22 for storing a class file 20 compressed based on the compression method of the program of the present invention, a method unit, and the basic information unit. A decompression unit 24 for decompressing the program, a program storage unit 26 for storing the method unit decompressed by the decompression unit 24, and a program execution unit 28 for interpreting and executing the decompressed program.
Have and.

The compression execution file storage unit 22 is uncompressed.
utf8 part, the compressed method part, uncompressed basic information part and uncompressed utf8 (data), method (subroutine)
Stores the page information of. The compression execution file storage unit 22 is preferably composed of NAND type and NOR type flash memories, and stores the compressed code in a NAND type flash memory which can be accessed only in page units but has a smaller chip area, Random access in units is possible, but the chip area is large NO
The uncompressed code is stored in the R-type flash memory (claim 13).

When the method (subroutine) of the class file is executed for the first time, the page of the method (subroutine) to be executed based on the page information of the arranged page is stored in the program storage unit 26 from the page information of the method (subroutine). Expand and execute the method (subroutine). When the method (subroutine) of the class file is executed for the second time or later, and when the method (subroutine) data is already expanded in the program storage unit 26, the expansion need not be performed again.

The program storage unit 26 is a cache memory, and it is necessary to confirm whether the method (subroutine) data has already been expanded in the cache by LRU (Least Receiving).
ntlyUsed) method. The cache LRU is checked for each page_size. 6.2 Form of Program Execution Device 2: Compress All This program execution device stores, as shown in FIG. 1, a compressed execution file storing the class file 20 compressed based on the compression method of the program of the present invention. Part 22
And a decompression unit 24 for decompressing and decompressing the compressed utf8 unit, method unit and basic information unit from the compression execution file storage unit 22, and a utf8 unit decompressed by the decompression unit 24, a method unit, and a basic unit. A program storage unit 26 for storing an information unit, interpreting the expanded program,
And a program execution unit 28 for executing the program.

The compression execution file storage section 22 stores the compressed utf8 section, the compressed method section, the compressed basic information section, the compressed utf8 (data), and the page information of the method (subroutine). The compression execution file storage unit 22 is preferably composed of NAND type and NOR type flash memories, and stores the compressed code in a NAND type flash memory which can be accessed only in page units but has a smaller chip area, The non-compressed code is stored in the NOR type flash memory which allows random access in units but increases the chip area (related to claim 13).

When the method (subroutine) of the class file is executed for the first time, the basic information section and utf8 (data) stored in the compression execution file storage section 22 and the page section of the method are first stored in the program storage section 26.
The class file basic information, utf8 (data), and method (subroutine) information are expanded. Next, the page of the method (subroutine) executed based on the arranged page information is stored in the program storage unit 26.
Expand to and execute the method (subroutine). When a method (subroutine) requests utf8 (data) information, ut is requested based on the page information placed above.
The page of f8 (data) is expanded in the program storage unit 26. When the method (subroutine) in the class file is executed for the second time and thereafter, the basic information section is not expanded. Further, when the method (subroutine) of the class file is executed for the second time or later, and when the utf8 (data) or method (subroutine) data is already expanded in the program storage unit 26, the expansion need not be performed again.

The program storage unit 26 is a cache memory, and whether the utf8 (data) or method (subroutine) data has already been expanded in the cache is confirmed by the LRU (Least Recently Used) method. The cache LRU is checked for each page_size. Due to the characteristics of this program execution device, it is possible to select a compression format having a high compression rate, a high decompression speed, or a hardware format that is easy to implement as the compression format of the data section and the subroutine section.

When an interpreter whose execution is relatively slow is used in the execution unit, it is preferable to use a compression format with a high compression rate. When using a JIT that executes relatively quickly, it is preferable to use a compression format that has a high decompression time.

[0114]

As described above, according to the present invention, it is only necessary to decompress a required page. Therefore, when executing an object-oriented language program, it is possible to decompress the entire executable file. Shorten the required processing time,
The memory capacity can be saved.

[Brief description of drawings]

FIG. 1 is a block diagram showing a program execution device of the present invention.

FIG. 2 is a diagram showing a top layer of a program compression format of the present invention.

FIG. 3 is a diagram showing a header layer of a program compression format of the present invention.

FIG. 4 is a diagram for explaining an example of compressing only the necessary lowest bit.

FIG. 5 is a diagram for explaining a page division method 1 for a method (subroutine) of the present invention.

FIG. 6 is a diagram for explaining a page division method 2 for a method (subroutine) of the present invention.

FIG. 7 is a page division method 1 for data according to the present invention.
It is a figure for explaining.

FIG. 8 is a page division method 2 for data according to the present invention.
It is a figure for explaining.

FIG. 9 is a flowchart for explaining a page division algorithm (page division methods 1 and 2) of the present invention.

FIG. 10 is a flowchart for explaining the page division algorithm (page division methods 1 and 2) of the present invention (continuation of FIG. 9).

FIG. 11 is a detailed diagram of a basic information section 4 in a program compression format.

FIG. 12 is a diagram showing a constant pool layer of a basic information section 4.

FIG. 13 is a detailed view of a constant pool layer.

FIG. 14 is a diagram showing an interface layer of a basic information section 4.

FIG. 15 is a diagram showing a field layer of a basic information section 4.

FIG. 16 is a detailed view of a field layer.

FIG. 17 is a diagram showing a fixed Huffman table specialized for attribute names.

FIG. 18 is a diagram showing a method (subroutine) layer of the basic information section 4.

FIG. 19 is a diagram showing attributes of a method (subroutine) layer.

FIG. 20 is a diagram showing attributes of a method (subroutine) layer.

FIG. 21 is a diagram showing code attributes of a method (subroutine) layer.

FIG. 22 is a diagram showing an attribute layer of the basic information section 4.

[Figure 23] utf8 (data), method (subroutine)
It is a figure which shows the page table of.

FIG. 24 is a diagram for explaining a method of confirming an address where the page is stored.

FIG. 25 is a page view of all compressed utf8 parts of the present invention.

FIG. 26 is a diagram of a page of all compressed methods (subroutines) of the present invention.

FIG. 27 is a diagram showing an example of page division of a method (subroutine) of the present invention.

[Explanation of symbols]

2 Compressed file format header section 4 Compressed file format basic information section 5 Compressed file format utf8 (data), page of method (subroutine) 6 Compressed file format utf8 section 8 Compressed file format method (subroutine) section 20 Program compressed by compressed file format 22 Compression execution file storage section 24 Decompression section 26 Program storage section 28 Execution section 40 Constant pool compression format of basic information section 42 Interface compression format of basic information section 44 Field compression format of basic information section 46 Method (subroutine) compression format of the basic information section 48 Attribute compression format of the basic information section 100 Instruction 3 and instruction 4 opcodes are macro-coded

   ─────────────────────────────────────────────────── ─── Continued front page    (72) Inventor Nobuyuki Kawahara             2-11-1, Senba-nishi, Minoh-shi, Osaka Stocks             Company Synthesis (72) Inventor Yoshinori Takeuchi             2-11-1, Senba-nishi, Minoh-shi, Osaka Stocks             Company Synthesis (72) Inventor Isao Shirakawa             2-11-1, Senba-nishi, Minoh-shi, Osaka Stocks             Company Synthesis (72) Inventor Toyohiko Yoshida             2-3 2-3 Marunouchi, Chiyoda-ku, Tokyo             Inside Ryo Electric Co., Ltd. (72) Inventor Mamoru Sakamoto             2-3 2-3 Marunouchi, Chiyoda-ku, Tokyo             Inside Ryo Electric Co., Ltd. F-term (reference) 5B060 DA08                 5B076 AB08

Claims (15)

[Claims] 1. A program, which is written in a predetermined language and is composed of one or a plurality of executable files, is assigned a subroutine included in a subroutine section of the executable file for each page, and the assigned subroutine is assigned. A method of compressing a program characterized by compressing in page units. 2. The data contained in the data part of the execution file is allocated for each page, and the allocated data is compressed in page units.
A method of compressing the described program. 3. The program compression method according to claim 1, wherein the page size of the allocated page is variable for each page, and the upper limit thereof is set. 4. The program compression method according to claim 1, wherein the page size of the allocated pages is the same for all pages. 5. The program compression method according to claim 2, wherein the compression method used in the subroutine page and the data page is changed. 6. When pages are allocated to a program composed of a plurality of execution files, the pages are divided so that a page including only subroutines of the same execution file is created according to information contained in the execution files. The method for compressing a program according to claim 1. 7. When allocating pages, the subroutines having larger sizes are aligned so that the subroutines are arranged at the top, and the following processes (A) and (B) are performed from the first page for each aligned subroutine. The method for compressing a program according to claim 1, wherein: (A) Check whether all the page sizes are free,
If all are free, assign the subroutine to the page and proceed to the next subroutine. If the subroutine is larger than the page size, the subroutine is assigned to the page, and some of the remaining unassigned subroutines are processed on the next page. (B) If the page is only partially free, check the free area of the page, and if the subroutine is smaller than the free area of the page, assign the subroutine to the page,
Go to the next subroutine. If the subroutine is larger than the free space of the page, the subroutine is processed on the next page without being assigned to the page. 8. When allocating pages, the subroutines having larger sizes are aligned so that the subroutines are arranged at the beginning, and the following processing (C) is performed for each aligned subroutine. How to compress the program. (C) Check the free area of the page, and if the subroutine is larger than the free area of the page, allocate the subroutine to the page, and process some of the remaining unallocated subroutines on the next page. If the subroutine is smaller than the free area of the page, the subroutine is assigned to the page and the process proceeds to the next subroutine. 9. When allocating pages, the subroutines are arranged so that the subroutines that are executed more frequently are aligned at the top, and the following processes (A) and (B) are performed from the first page for each aligned subroutine. The method for compressing a program according to claim 1, wherein: (A) Check whether all the page sizes are free,
If all are free, assign the subroutine to the page and proceed to the next subroutine. If the subroutine is larger than the page size, the subroutine is assigned to the page, and some of the remaining unassigned subroutines are processed on the next page. (B) If the page is only partially free, check the free area of the page, and if the subroutine is smaller than the free area of the page, assign the subroutine to the page,
Go to the next subroutine. If the subroutine is larger than the free space of the page, the subroutine is processed on the next page without being assigned to the page. 10. When allocating pages, the subroutines are arranged so that the subroutines that are executed more frequently are arranged at the top, and the following processing (C) is performed for each of the arranged subroutines. How to compress the program. (C) Check the free area of the page, and if the subroutine is larger than the free area of the page, allocate the subroutine to the page, and process some of the remaining unallocated subroutines on the next page. If the subroutine is smaller than the free area of the page, the subroutine is assigned to the page and the process proceeds to the next subroutine. 11. A program compression method according to claim 1, wherein after page allocation, each instruction in the subroutine is replaced by macro conversion and then compressed. 12. The method of compressing a program according to claim 1, wherein the compression algorithm can be changed for each page. 13. The program compression method according to claim 1, wherein only pages having a page compression ratio (size before compression / size after compression) of a certain value or more are compressed, and pages not so compressed are not compressed. 14. A program written in a predetermined language is Ja
va (R) (registered trademark of Sun Microsystems, Inc.) class file, which is a Java class file in i) method part which is a subroutine, ii) utf8 part which is data, and iii) other basic information part In i), a) a high-speed dictionary-based compression algorithm, b) a compression algorithm with a high compression ratio that combines a dictionary-based and adaptive Huffman table,
c) The compression algorithm of a) is applied after each instruction in the subroutine is replaced by macro conversion, and d) The compression algorithm of b) is applied after each instruction in the subroutine is replaced by macro conversion. Compression algorithm, or e) compressing using a compression algorithm that applies fixed Huffman table compression algorithm after replacing each instruction in the subroutine by macro conversion, and in ii) a) using the initial dictionary Compression algorithm based on a simple dictionary or b) using a compression algorithm combining a dictionary base with a high compression rate using the initial dictionary and an adaptive Huffman table, and the number of symbols of the type represented by the data to be compressed in iii) is If this is a premise, assign shorter codes to the symbols that are used more frequently, and assign longer codes as the frequency of use decreases. Performs compression Te, when data to be compressed in iii) is a number of 0 to n, the lower the data
| Log ₂ n | (| | represents rounding up to an integer) Only the bits are encoded and compressed. 15. A program written in a predetermined language is Ja
va (R) (registered trademark of Sun Microsystems, Inc.) class file in which a Java class file is i) a method part that is a subroutine, ii) utf8 part that is data,
And iii) divide into basic information parts other than these, i) divide the subroutine into pages according to the method of claim 1, and divide the page into a) a fast dictionary-based compression algorithm, b) a dictionary base with a high compression rate. Adaptive Huffman table combination compression algorithm, c) A compression algorithm that applies the compression algorithm of a) after replacing each instruction in the subroutine by macro conversion, and d) Replaces each instruction in the subroutine by macro conversion. After that, compression is performed using the compression algorithm of b) or e) the compression algorithm of applying the fixed Huffman table compression algorithm after replacing each instruction in the subroutine by macro conversion, and ii) Then, divide all utf8 (data) into multiple pages, and make each page consisting of multiple utf8 (data) page by page a) Initial dictionary A high-speed dictionary-based compression algorithm or b) a compression algorithm that uses a combination of a dictionary-based and an adaptive Huffman table with a high compression ratio using the initial dictionary, and the symbol of the type represented by the data to be compressed in iii) If the number is a prerequisite, assign shorter codes to frequently used symbols, assign longer codes as less frequently used, perform compression, and compress data in iii) from 0 to n (n is iii). (Information contained in), the lower part of the data ｜ log ₂ n ｜
A compression method for a program, wherein only bits (| | represents rounding up to an integer) are encoded and compressed.